diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb7d5e6..b502006 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -128,6 +128,8 @@
             "${AOM_ROOT}/aom/src/aom_integer.c")
 
 list(APPEND AOM_COMMON_APP_UTIL_SOURCES
+            "${AOM_ROOT}/av1/arg_defs.h"
+            "${AOM_ROOT}/av1/arg_defs.c"
             "${AOM_ROOT}/common/args_helper.c"
             "${AOM_ROOT}/common/args_helper.h"
             "${AOM_ROOT}/common/args.c"
diff --git a/aom/aom_codec.h b/aom/aom_codec.h
index 6e4208d..f58272e 100644
--- a/aom/aom_codec.h
+++ b/aom/aom_codec.h
@@ -149,7 +149,7 @@
  * types, removing or reassigning enums, adding/removing/rearranging
  * fields to structures
  */
-#define AOM_CODEC_ABI_VERSION (5 + AOM_IMAGE_ABI_VERSION) /**<\hideinitializer*/
+#define AOM_CODEC_ABI_VERSION (6 + AOM_IMAGE_ABI_VERSION) /**<\hideinitializer*/
 
 /*!\brief Algorithm return codes */
 typedef enum {
@@ -490,6 +490,26 @@
  */
 aom_codec_err_t aom_codec_control(aom_codec_ctx_t *ctx, int ctrl_id, ...);
 
+/*!\brief Key & Value API
+ *
+ * aom_codec_set_option() takes a context, a key (option name) and a value. If
+ * the context is non-null and an error occurs, ctx->err will be set to the same
+ * value as the return value.
+ *
+ * \param[in]     ctx              Pointer to this instance's context
+ * \param[in]     name             The name of the option (key)
+ * \param[in]     value            The value of the option
+ *
+ * \retval #AOM_CODEC_OK
+ *     The value of the option was set.
+ * \retval #AOM_CODEC_INVALID_PARAM
+ *     The data was not valid.
+ * \retval #AOM_CODEC_ERROR
+ *     The option was not successfully set.
+ */
+aom_codec_err_t aom_codec_set_option(aom_codec_ctx_t *ctx, const char *name,
+                                     const char *value);
+
 /*!\brief aom_codec_control wrapper macro (adds type-checking, less flexible)
  *
  * This macro allows for type safe conversions across the variadic parameter
diff --git a/aom/internal/aom_codec_internal.h b/aom/internal/aom_codec_internal.h
index efebd17..0ad33bd 100644
--- a/aom/internal/aom_codec_internal.h
+++ b/aom/internal/aom_codec_internal.h
@@ -47,6 +47,7 @@
 #define AOM_AOM_INTERNAL_AOM_CODEC_INTERNAL_H_
 #include "../aom_decoder.h"
 #include "../aom_encoder.h"
+#include "common/args_helper.h"
 #include <stdarg.h>
 
 #ifdef __cplusplus
@@ -153,6 +154,23 @@
 typedef aom_codec_err_t (*aom_codec_control_fn_t)(aom_codec_alg_priv_t *ctx,
                                                   va_list ap);
 
+/*!\brief codec option setter function pointer prototype
+ * This function is used to set a codec option using a key (option name) & value
+ * pair.
+ *
+ * \param[in]     ctx              Pointer to this instance's context
+ * \param[in]     name             A string of the option's name (key)
+ * \param[in]     value            A string of the value to be set to
+ *
+ * \retval #AOM_CODEC_OK
+ *     The option is successfully set to the value
+ * \retval #AOM_CODEC_INVALID_PARAM
+ *     The data was not valid.
+ */
+typedef aom_codec_err_t (*aom_codec_set_option_fn_t)(aom_codec_alg_priv_t *ctx,
+                                                     const char *name,
+                                                     const char *value);
+
 /*!\brief control function pointer mapping
  *
  * This structure stores the mapping between control identifiers and
@@ -292,6 +310,7 @@
     aom_codec_get_preview_frame_fn_t
         get_preview; /**< \copydoc ::aom_codec_get_preview_frame_fn_t */
   } enc;
+  aom_codec_set_option_fn_t set_option;
 };
 
 /*!\brief Instance private storage
@@ -351,7 +370,7 @@
 struct aom_internal_error_info {
   aom_codec_err_t error_code;
   int has_detail;
-  char detail[80];
+  char detail[ARG_ERR_MSG_MAX_LEN];
   int setjmp;  // Boolean: whether 'jmp' is valid.
   jmp_buf jmp;
 };
diff --git a/aom/src/aom_codec.c b/aom/src/aom_codec.c
index d418463..4778781 100644
--- a/aom/src/aom_codec.c
+++ b/aom/src/aom_codec.c
@@ -114,6 +114,20 @@
   return AOM_CODEC_ERROR;
 }
 
+aom_codec_err_t aom_codec_set_option(aom_codec_ctx_t *ctx, const char *name,
+                                     const char *value) {
+  if (!ctx) {
+    return AOM_CODEC_INVALID_PARAM;
+  }
+  if (!ctx->iface || !ctx->priv || !ctx->iface->set_option) {
+    ctx->err = AOM_CODEC_ERROR;
+    return AOM_CODEC_ERROR;
+  }
+  ctx->err =
+      ctx->iface->set_option((aom_codec_alg_priv_t *)ctx->priv, name, value);
+  return ctx->err;
+}
+
 void aom_internal_error(struct aom_internal_error_info *info,
                         aom_codec_err_t error, const char *fmt, ...) {
   va_list ap;
diff --git a/apps/aomenc.c b/apps/aomenc.c
index 19a4524..789cd60 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -123,824 +123,6 @@
   return 0;
 }
 
-static const arg_def_t help =
-    ARG_DEF(NULL, "help", 0, "Show usage options and exit");
-static const arg_def_t debugmode =
-    ARG_DEF("D", "debug", 0, "Debug mode (makes output deterministic)");
-static const arg_def_t outputfile =
-    ARG_DEF("o", "output", 1, "Output filename");
-static const arg_def_t use_yv12 =
-    ARG_DEF(NULL, "yv12", 0, "Input file is YV12 ");
-static const arg_def_t use_i420 =
-    ARG_DEF(NULL, "i420", 0, "Input file is I420 (default)");
-static const arg_def_t use_i422 =
-    ARG_DEF(NULL, "i422", 0, "Input file is I422");
-static const arg_def_t use_i444 =
-    ARG_DEF(NULL, "i444", 0, "Input file is I444");
-static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1, "Codec to use");
-static const arg_def_t passes =
-    ARG_DEF("p", "passes", 1, "Number of passes (1/2)");
-static const arg_def_t pass_arg =
-    ARG_DEF(NULL, "pass", 1, "Pass to execute (1/2)");
-static const arg_def_t fpf_name =
-    ARG_DEF(NULL, "fpf", 1, "First pass statistics file name");
-static const arg_def_t limit =
-    ARG_DEF(NULL, "limit", 1, "Stop encoding after n input frames");
-static const arg_def_t skip =
-    ARG_DEF(NULL, "skip", 1, "Skip the first n input frames");
-static const arg_def_t good_dl =
-    ARG_DEF(NULL, "good", 0, "Use Good Quality Deadline");
-static const arg_def_t rt_dl =
-    ARG_DEF(NULL, "rt", 0, "Use Realtime Quality Deadline");
-static const arg_def_t quietarg =
-    ARG_DEF("q", "quiet", 0, "Do not print encode progress");
-static const arg_def_t verbosearg =
-    ARG_DEF("v", "verbose", 0, "Show encoder parameters");
-static const arg_def_t psnrarg = ARG_DEF(
-    NULL, "psnr", -1,
-    "Show PSNR in status line"
-    "(0: Disable PSNR status line display, 1: PSNR calculated using input "
-    "bit-depth (default), 2: PSNR calculated using stream bit-depth), "
-    "takes default option when arguments are not specified");
-static const arg_def_t use_cfg = ARG_DEF("c", "cfg", 1, "Config file to use");
-
-static const struct arg_enum_list test_decode_enum[] = {
-  { "off", TEST_DECODE_OFF },
-  { "fatal", TEST_DECODE_FATAL },
-  { "warn", TEST_DECODE_WARN },
-  { NULL, 0 }
-};
-static const arg_def_t recontest = ARG_DEF_ENUM(
-    NULL, "test-decode", 1, "Test encode/decode mismatch", test_decode_enum);
-static const arg_def_t framerate =
-    ARG_DEF(NULL, "fps", 1, "Stream frame rate (rate/scale)");
-static const arg_def_t use_webm =
-    ARG_DEF(NULL, "webm", 0, "Output WebM (default when WebM IO is enabled)");
-static const arg_def_t use_ivf = ARG_DEF(NULL, "ivf", 0, "Output IVF");
-static const arg_def_t use_obu = ARG_DEF(NULL, "obu", 0, "Output OBU");
-static const arg_def_t q_hist_n =
-    ARG_DEF(NULL, "q-hist", 1, "Show quantizer histogram (n-buckets)");
-static const arg_def_t rate_hist_n =
-    ARG_DEF(NULL, "rate-hist", 1, "Show rate histogram (n-buckets)");
-static const arg_def_t disable_warnings =
-    ARG_DEF(NULL, "disable-warnings", 0,
-            "Disable warnings about potentially incorrect encode settings.");
-static const arg_def_t disable_warning_prompt =
-    ARG_DEF("y", "disable-warning-prompt", 0,
-            "Display warnings, but do not prompt user to continue.");
-static const struct arg_enum_list bitdepth_enum[] = {
-  { "8", AOM_BITS_8 }, { "10", AOM_BITS_10 }, { "12", AOM_BITS_12 }, { NULL, 0 }
-};
-
-static const arg_def_t bitdeptharg = ARG_DEF_ENUM(
-    "b", "bit-depth", 1,
-    "Bit depth for codec (8 for version <=1, 10 or 12 for version 2)",
-    bitdepth_enum);
-static const arg_def_t inbitdeptharg =
-    ARG_DEF(NULL, "input-bit-depth", 1, "Bit depth of input");
-
-static const arg_def_t input_chroma_subsampling_x = ARG_DEF(
-    NULL, "input-chroma-subsampling-x", 1, "chroma subsampling x value.");
-static const arg_def_t input_chroma_subsampling_y = ARG_DEF(
-    NULL, "input-chroma-subsampling-y", 1, "chroma subsampling y value.");
-
-static const arg_def_t *main_args[] = { &help,
-                                        &use_cfg,
-                                        &debugmode,
-                                        &outputfile,
-                                        &codecarg,
-                                        &passes,
-                                        &pass_arg,
-                                        &fpf_name,
-                                        &limit,
-                                        &skip,
-                                        &good_dl,
-                                        &rt_dl,
-                                        &quietarg,
-                                        &verbosearg,
-                                        &psnrarg,
-                                        &use_webm,
-                                        &use_ivf,
-                                        &use_obu,
-                                        &q_hist_n,
-                                        &rate_hist_n,
-                                        &disable_warnings,
-                                        &disable_warning_prompt,
-                                        &recontest,
-                                        NULL };
-
-static const arg_def_t usage =
-    ARG_DEF("u", "usage", 1, "Usage profile number to use");
-static const arg_def_t threads =
-    ARG_DEF("t", "threads", 1, "Max number of threads to use");
-static const arg_def_t profile =
-    ARG_DEF(NULL, "profile", 1, "Bitstream profile number to use");
-static const arg_def_t width = ARG_DEF("w", "width", 1, "Frame width");
-static const arg_def_t height = ARG_DEF("h", "height", 1, "Frame height");
-static const arg_def_t forced_max_frame_width = ARG_DEF(
-    NULL, "forced_max_frame_width", 1, "Maximum frame width value to force");
-static const arg_def_t forced_max_frame_height = ARG_DEF(
-    NULL, "forced_max_frame_height", 1, "Maximum frame height value to force");
-#if CONFIG_WEBM_IO
-static const struct arg_enum_list stereo_mode_enum[] = {
-  { "mono", STEREO_FORMAT_MONO },
-  { "left-right", STEREO_FORMAT_LEFT_RIGHT },
-  { "bottom-top", STEREO_FORMAT_BOTTOM_TOP },
-  { "top-bottom", STEREO_FORMAT_TOP_BOTTOM },
-  { "right-left", STEREO_FORMAT_RIGHT_LEFT },
-  { NULL, 0 }
-};
-static const arg_def_t stereo_mode = ARG_DEF_ENUM(
-    NULL, "stereo-mode", 1, "Stereo 3D video format", stereo_mode_enum);
-#endif
-static const arg_def_t timebase = ARG_DEF(
-    NULL, "timebase", 1, "Output timestamp precision (fractional seconds)");
-static const arg_def_t global_error_resilient =
-    ARG_DEF(NULL, "global-error-resilient", 1,
-            "Enable global error resiliency features");
-static const arg_def_t lag_in_frames =
-    ARG_DEF(NULL, "lag-in-frames", 1, "Max number of frames to lag");
-static const arg_def_t large_scale_tile = ARG_DEF(
-    NULL, "large-scale-tile", 1,
-    "Large scale tile coding (0: off (default), 1: on (ivf output only))");
-static const arg_def_t monochrome =
-    ARG_DEF(NULL, "monochrome", 0, "Monochrome video (no chroma planes)");
-static const arg_def_t full_still_picture_hdr = ARG_DEF(
-    NULL, "full-still-picture-hdr", 0, "Use full header for still picture");
-static const arg_def_t use_16bit_internal =
-    ARG_DEF(NULL, "use-16bit-internal", 0, "Force use of 16-bit pipeline");
-
-static const arg_def_t *global_args[] = { &use_yv12,
-                                          &use_i420,
-                                          &use_i422,
-                                          &use_i444,
-                                          &usage,
-                                          &threads,
-                                          &profile,
-                                          &width,
-                                          &height,
-                                          &forced_max_frame_width,
-                                          &forced_max_frame_height,
-#if CONFIG_WEBM_IO
-                                          &stereo_mode,
-#endif
-                                          &timebase,
-                                          &framerate,
-                                          &global_error_resilient,
-                                          &bitdeptharg,
-                                          &lag_in_frames,
-                                          &large_scale_tile,
-                                          &monochrome,
-                                          &full_still_picture_hdr,
-                                          &use_16bit_internal,
-                                          NULL };
-
-static const arg_def_t dropframe_thresh =
-    ARG_DEF(NULL, "drop-frame", 1, "Temporal resampling threshold (buf %)");
-static const arg_def_t resize_mode =
-    ARG_DEF(NULL, "resize-mode", 1, "Frame resize mode");
-static const arg_def_t resize_denominator =
-    ARG_DEF(NULL, "resize-denominator", 1, "Frame resize denominator");
-static const arg_def_t resize_kf_denominator = ARG_DEF(
-    NULL, "resize-kf-denominator", 1, "Frame resize keyframe denominator");
-static const arg_def_t superres_mode =
-    ARG_DEF(NULL, "superres-mode", 1, "Frame super-resolution mode");
-static const arg_def_t superres_denominator = ARG_DEF(
-    NULL, "superres-denominator", 1, "Frame super-resolution denominator");
-static const arg_def_t superres_kf_denominator =
-    ARG_DEF(NULL, "superres-kf-denominator", 1,
-            "Frame super-resolution keyframe denominator");
-static const arg_def_t superres_qthresh = ARG_DEF(
-    NULL, "superres-qthresh", 1, "Frame super-resolution qindex threshold");
-static const arg_def_t superres_kf_qthresh =
-    ARG_DEF(NULL, "superres-kf-qthresh", 1,
-            "Frame super-resolution keyframe qindex threshold");
-static const struct arg_enum_list end_usage_enum[] = { { "vbr", AOM_VBR },
-                                                       { "cbr", AOM_CBR },
-                                                       { "cq", AOM_CQ },
-                                                       { "q", AOM_Q },
-                                                       { NULL, 0 } };
-static const arg_def_t end_usage =
-    ARG_DEF_ENUM(NULL, "end-usage", 1, "Rate control mode", end_usage_enum);
-static const arg_def_t target_bitrate =
-    ARG_DEF(NULL, "target-bitrate", 1, "Bitrate (kbps)");
-static const arg_def_t min_quantizer =
-    ARG_DEF(NULL, "min-q", 1, "Minimum (best) quantizer");
-static const arg_def_t max_quantizer =
-    ARG_DEF(NULL, "max-q", 1, "Maximum (worst) quantizer");
-static const arg_def_t undershoot_pct =
-    ARG_DEF(NULL, "undershoot-pct", 1, "Datarate undershoot (min) target (%)");
-static const arg_def_t overshoot_pct =
-    ARG_DEF(NULL, "overshoot-pct", 1, "Datarate overshoot (max) target (%)");
-static const arg_def_t buf_sz =
-    ARG_DEF(NULL, "buf-sz", 1, "Client buffer size (ms)");
-static const arg_def_t buf_initial_sz =
-    ARG_DEF(NULL, "buf-initial-sz", 1, "Client initial buffer size (ms)");
-static const arg_def_t buf_optimal_sz =
-    ARG_DEF(NULL, "buf-optimal-sz", 1, "Client optimal buffer size (ms)");
-static const arg_def_t bias_pct =
-    ARG_DEF(NULL, "bias-pct", 1, "CBR/VBR bias (0=CBR, 100=VBR)");
-static const arg_def_t minsection_pct =
-    ARG_DEF(NULL, "minsection-pct", 1, "GOP min bitrate (% of target)");
-static const arg_def_t maxsection_pct =
-    ARG_DEF(NULL, "maxsection-pct", 1, "GOP max bitrate (% of target)");
-static const arg_def_t *rc_args[] = { &dropframe_thresh,
-                                      &resize_mode,
-                                      &resize_denominator,
-                                      &resize_kf_denominator,
-                                      &superres_mode,
-                                      &superres_denominator,
-                                      &superres_kf_denominator,
-                                      &superres_qthresh,
-                                      &superres_kf_qthresh,
-                                      &end_usage,
-                                      &target_bitrate,
-                                      &min_quantizer,
-                                      &max_quantizer,
-                                      &undershoot_pct,
-                                      &overshoot_pct,
-                                      &buf_sz,
-                                      &buf_initial_sz,
-                                      &buf_optimal_sz,
-                                      &bias_pct,
-                                      &minsection_pct,
-                                      &maxsection_pct,
-                                      NULL };
-
-static const arg_def_t fwd_kf_enabled =
-    ARG_DEF(NULL, "enable-fwd-kf", 1, "Enable forward reference keyframes");
-static const arg_def_t kf_min_dist =
-    ARG_DEF(NULL, "kf-min-dist", 1, "Minimum keyframe interval (frames)");
-static const arg_def_t kf_max_dist =
-    ARG_DEF(NULL, "kf-max-dist", 1, "Maximum keyframe interval (frames)");
-static const arg_def_t kf_disabled =
-    ARG_DEF(NULL, "disable-kf", 0, "Disable keyframe placement");
-static const arg_def_t *kf_args[] = { &fwd_kf_enabled, &kf_min_dist,
-                                      &kf_max_dist, &kf_disabled, NULL };
-static const arg_def_t sframe_dist =
-    ARG_DEF(NULL, "sframe-dist", 1, "S-Frame interval (frames)");
-static const arg_def_t sframe_mode =
-    ARG_DEF(NULL, "sframe-mode", 1, "S-Frame insertion mode (1..2)");
-static const arg_def_t save_as_annexb =
-    ARG_DEF(NULL, "annexb", 1, "Save as Annex-B");
-static const arg_def_t noise_sens =
-    ARG_DEF(NULL, "noise-sensitivity", 1, "Noise sensitivity (frames to blur)");
-static const arg_def_t sharpness =
-    ARG_DEF(NULL, "sharpness", 1, "Loop filter sharpness (0..7), default is 0");
-static const arg_def_t static_thresh =
-    ARG_DEF(NULL, "static-thresh", 1, "Motion detection threshold");
-static const arg_def_t auto_altref =
-    ARG_DEF(NULL, "auto-alt-ref", 1, "Enable automatic alt reference frames");
-static const arg_def_t arnr_maxframes =
-    ARG_DEF(NULL, "arnr-maxframes", 1, "AltRef max frames (0..15)");
-static const arg_def_t arnr_strength =
-    ARG_DEF(NULL, "arnr-strength", 1, "AltRef filter strength (0..6)");
-static const struct arg_enum_list tuning_enum[] = {
-  { "psnr", AOM_TUNE_PSNR },
-  { "ssim", AOM_TUNE_SSIM },
-  { "vmaf_with_preprocessing", AOM_TUNE_VMAF_WITH_PREPROCESSING },
-  { "vmaf_without_preprocessing", AOM_TUNE_VMAF_WITHOUT_PREPROCESSING },
-  { "vmaf", AOM_TUNE_VMAF_MAX_GAIN },
-  { "vmaf_neg", AOM_TUNE_VMAF_NEG_MAX_GAIN },
-  { NULL, 0 }
-};
-static const arg_def_t tune_metric =
-    ARG_DEF_ENUM(NULL, "tune", 1, "Distortion metric tuned with", tuning_enum);
-static const arg_def_t cq_level =
-    ARG_DEF(NULL, "cq-level", 1, "Constant/Constrained Quality level");
-static const arg_def_t max_intra_rate_pct =
-    ARG_DEF(NULL, "max-intra-rate", 1, "Max I-frame bitrate (pct)");
-
-#if CONFIG_AV1_ENCODER
-static const arg_def_t cpu_used_av1 =
-    ARG_DEF(NULL, "cpu-used", 1,
-            "Speed setting (0..6 in good mode, 6..9 in realtime mode)");
-static const arg_def_t rowmtarg =
-    ARG_DEF(NULL, "row-mt", 1,
-            "Enable row based multi-threading (0: off, 1: on (default))");
-static const arg_def_t tile_cols =
-    ARG_DEF(NULL, "tile-columns", 1, "Number of tile columns to use, log2");
-static const arg_def_t tile_rows =
-    ARG_DEF(NULL, "tile-rows", 1, "Number of tile rows to use, log2");
-static const arg_def_t enable_tpl_model =
-    ARG_DEF(NULL, "enable-tpl-model", 1,
-            "RDO based on frame temporal dependency "
-            "(0: off, 1: backward source based). "
-            "This is required for deltaq mode.");
-static const arg_def_t enable_keyframe_filtering =
-    ARG_DEF(NULL, "enable-keyframe-filtering", 1,
-            "Apply temporal filtering on key frame"
-            "(0: no filter, 1: filter without overlay (default), "
-            "2: filter with overlay - experimental, may break random access in "
-            "players.)");
-static const arg_def_t tile_width =
-    ARG_DEF(NULL, "tile-width", 1, "Tile widths (comma separated)");
-static const arg_def_t tile_height =
-    ARG_DEF(NULL, "tile-height", 1, "Tile heights (command separated)");
-static const arg_def_t lossless =
-    ARG_DEF(NULL, "lossless", 1, "Lossless mode (0: false (default), 1: true)");
-static const arg_def_t enable_cdef =
-    ARG_DEF(NULL, "enable-cdef", 1,
-            "Enable the constrained directional enhancement filter (0: false, "
-            "1: true (default))");
-static const arg_def_t enable_restoration = ARG_DEF(
-    NULL, "enable-restoration", 1,
-    "Enable the loop restoration filter (0: false (default in Realtime mode), "
-    "1: true (default in Non-realtime mode))");
-static const arg_def_t enable_rect_partitions =
-    ARG_DEF(NULL, "enable-rect-partitions", 1,
-            "Enable rectangular partitions "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_ab_partitions =
-    ARG_DEF(NULL, "enable-ab-partitions", 1,
-            "Enable ab partitions (0: false, 1: true (default))");
-static const arg_def_t enable_1to4_partitions =
-    ARG_DEF(NULL, "enable-1to4-partitions", 1,
-            "Enable 1:4 and 4:1 partitions "
-            "(0: false, 1: true (default))");
-static const arg_def_t min_partition_size =
-    ARG_DEF(NULL, "min-partition-size", 1,
-            "Set min partition size "
-            "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128). "
-            "On frame with 4k+ resolutions or higher speed settings, the min "
-            "partition size will have a minimum of 8.");
-static const arg_def_t max_partition_size =
-    ARG_DEF(NULL, "max-partition-size", 1,
-            "Set max partition size "
-            "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128)");
-static const arg_def_t enable_dual_filter =
-    ARG_DEF(NULL, "enable-dual-filter", 1,
-            "Enable dual filter "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_chroma_deltaq =
-    ARG_DEF(NULL, "enable-chroma-deltaq", 1,
-            "Enable chroma delta quant "
-            "(0: false (default), 1: true)");
-static const arg_def_t enable_intra_edge_filter =
-    ARG_DEF(NULL, "enable-intra-edge-filter", 1,
-            "Enable intra edge filtering "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_order_hint =
-    ARG_DEF(NULL, "enable-order-hint", 1,
-            "Enable order hint "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_tx64 =
-    ARG_DEF(NULL, "enable-tx64", 1,
-            "Enable 64-pt transform (0: false, 1: true (default))");
-static const arg_def_t enable_flip_idtx =
-    ARG_DEF(NULL, "enable-flip-idtx", 1,
-            "Enable extended transform type (0: false, 1: true (default)) "
-            "including FLIPADST_DCT, DCT_FLIPADST, FLIPADST_FLIPADST, "
-            "ADST_FLIPADST, FLIPADST_ADST, IDTX, V_DCT, H_DCT, V_ADST, "
-            "H_ADST, V_FLIPADST, H_FLIPADST");
-static const arg_def_t enable_rect_tx =
-    ARG_DEF(NULL, "enable-rect-tx", 1,
-            "Enable rectangular transform (0: false, 1: true (default))");
-static const arg_def_t enable_dist_wtd_comp =
-    ARG_DEF(NULL, "enable-dist-wtd-comp", 1,
-            "Enable distance-weighted compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_masked_comp =
-    ARG_DEF(NULL, "enable-masked-comp", 1,
-            "Enable masked (wedge/diff-wtd) compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_onesided_comp =
-    ARG_DEF(NULL, "enable-onesided-comp", 1,
-            "Enable one sided compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_interintra_comp =
-    ARG_DEF(NULL, "enable-interintra-comp", 1,
-            "Enable interintra compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_smooth_interintra =
-    ARG_DEF(NULL, "enable-smooth-interintra", 1,
-            "Enable smooth interintra mode "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_diff_wtd_comp =
-    ARG_DEF(NULL, "enable-diff-wtd-comp", 1,
-            "Enable difference-weighted compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_interinter_wedge =
-    ARG_DEF(NULL, "enable-interinter-wedge", 1,
-            "Enable interinter wedge compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_interintra_wedge =
-    ARG_DEF(NULL, "enable-interintra-wedge", 1,
-            "Enable interintra wedge compound "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_global_motion =
-    ARG_DEF(NULL, "enable-global-motion", 1,
-            "Enable global motion "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_warped_motion =
-    ARG_DEF(NULL, "enable-warped-motion", 1,
-            "Enable local warped motion "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_filter_intra =
-    ARG_DEF(NULL, "enable-filter-intra", 1,
-            "Enable filter intra prediction mode "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_smooth_intra =
-    ARG_DEF(NULL, "enable-smooth-intra", 1,
-            "Enable smooth intra prediction modes "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_paeth_intra =
-    ARG_DEF(NULL, "enable-paeth-intra", 1,
-            "Enable Paeth intra prediction mode (0: false, 1: true (default))");
-static const arg_def_t enable_cfl_intra =
-    ARG_DEF(NULL, "enable-cfl-intra", 1,
-            "Enable chroma from luma intra prediction mode "
-            "(0: false, 1: true (default))");
-static const arg_def_t force_video_mode =
-    ARG_DEF(NULL, "force-video-mode", 1,
-            "Force video mode (0: false, 1: true (default))");
-static const arg_def_t enable_obmc = ARG_DEF(
-    NULL, "enable-obmc", 1, "Enable OBMC (0: false, 1: true (default))");
-static const arg_def_t enable_overlay =
-    ARG_DEF(NULL, "enable-overlay", 1,
-            "Enable coding overlay frames (0: false, 1: true (default))");
-static const arg_def_t enable_palette =
-    ARG_DEF(NULL, "enable-palette", 1,
-            "Enable palette prediction mode (0: false, 1: true (default))");
-static const arg_def_t enable_intrabc =
-    ARG_DEF(NULL, "enable-intrabc", 1,
-            "Enable intra block copy prediction mode "
-            "(0: false, 1: true (default))");
-static const arg_def_t enable_angle_delta =
-    ARG_DEF(NULL, "enable-angle-delta", 1,
-            "Enable intra angle delta (0: false, 1: true (default))");
-static const arg_def_t disable_trellis_quant =
-    ARG_DEF(NULL, "disable-trellis-quant", 1,
-            "Disable trellis optimization of quantized coefficients (0: false "
-            "1: true  2: true for rd search 3: true for estimate yrd serch "
-            "(default))");
-static const arg_def_t enable_qm =
-    ARG_DEF(NULL, "enable-qm", 1,
-            "Enable quantisation matrices (0: false (default), 1: true)");
-static const arg_def_t qm_min = ARG_DEF(
-    NULL, "qm-min", 1, "Min quant matrix flatness (0..15), default is 8");
-static const arg_def_t qm_max = ARG_DEF(
-    NULL, "qm-max", 1, "Max quant matrix flatness (0..15), default is 15");
-static const arg_def_t reduced_tx_type_set = ARG_DEF(
-    NULL, "reduced-tx-type-set", 1, "Use reduced set of transform types");
-static const arg_def_t use_intra_dct_only =
-    ARG_DEF(NULL, "use-intra-dct-only", 1, "Use DCT only for INTRA modes");
-static const arg_def_t use_inter_dct_only =
-    ARG_DEF(NULL, "use-inter-dct-only", 1, "Use DCT only for INTER modes");
-static const arg_def_t use_intra_default_tx_only =
-    ARG_DEF(NULL, "use-intra-default-tx-only", 1,
-            "Use Default-transform only for INTRA modes");
-static const arg_def_t quant_b_adapt =
-    ARG_DEF(NULL, "quant-b-adapt", 1, "Use adaptive quantize_b");
-static const arg_def_t coeff_cost_upd_freq =
-    ARG_DEF(NULL, "coeff-cost-upd-freq", 1,
-            "Update freq for coeff costs"
-            "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off");
-static const arg_def_t mode_cost_upd_freq =
-    ARG_DEF(NULL, "mode-cost-upd-freq", 1,
-            "Update freq for mode costs"
-            "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off");
-static const arg_def_t mv_cost_upd_freq =
-    ARG_DEF(NULL, "mv-cost-upd-freq", 1,
-            "Update freq for mv costs"
-            "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off");
-static const arg_def_t num_tg = ARG_DEF(
-    NULL, "num-tile-groups", 1, "Maximum number of tile groups, default is 1");
-static const arg_def_t mtu_size =
-    ARG_DEF(NULL, "mtu-size", 1,
-            "MTU size for a tile group, default is 0 (no MTU targeting), "
-            "overrides maximum number of tile groups");
-static const struct arg_enum_list timing_info_enum[] = {
-  { "unspecified", AOM_TIMING_UNSPECIFIED },
-  { "constant", AOM_TIMING_EQUAL },
-  { "model", AOM_TIMING_DEC_MODEL },
-  { NULL, 0 }
-};
-static const arg_def_t timing_info =
-    ARG_DEF_ENUM(NULL, "timing-info", 1,
-                 "Signal timing info in the bitstream (model unly works for no "
-                 "hidden frames, no super-res yet):",
-                 timing_info_enum);
-#if CONFIG_TUNE_VMAF
-static const arg_def_t vmaf_model_path =
-    ARG_DEF(NULL, "vmaf-model-path", 1, "Path to the VMAF model file");
-#endif
-static const arg_def_t film_grain_test =
-    ARG_DEF(NULL, "film-grain-test", 1,
-            "Film grain test vectors (0: none (default), 1: test-1  2: test-2, "
-            "... 16: test-16)");
-static const arg_def_t film_grain_table =
-    ARG_DEF(NULL, "film-grain-table", 1,
-            "Path to file containing film grain parameters");
-#if CONFIG_DENOISE
-static const arg_def_t denoise_noise_level =
-    ARG_DEF(NULL, "denoise-noise-level", 1,
-            "Amount of noise (from 0 = don't denoise, to 50)");
-static const arg_def_t denoise_block_size =
-    ARG_DEF(NULL, "denoise-block-size", 1, "Denoise block size (default = 32)");
-#endif
-static const arg_def_t enable_ref_frame_mvs =
-    ARG_DEF(NULL, "enable-ref-frame-mvs", 1,
-            "Enable temporal mv prediction (default is 1)");
-static const arg_def_t frame_parallel_decoding =
-    ARG_DEF(NULL, "frame-parallel", 1,
-            "Enable frame parallel decodability features "
-            "(0: false (default), 1: true)");
-static const arg_def_t error_resilient_mode =
-    ARG_DEF(NULL, "error-resilient", 1,
-            "Enable error resilient features "
-            "(0: false (default), 1: true)");
-static const arg_def_t aq_mode = ARG_DEF(
-    NULL, "aq-mode", 1,
-    "Adaptive quantization mode (0: off (default), 1: variance 2: complexity, "
-    "3: cyclic refresh)");
-static const arg_def_t deltaq_mode =
-    ARG_DEF(NULL, "deltaq-mode", 1,
-            "Delta qindex mode (0: off, 1: deltaq objective (default), "
-            "2: deltaq perceptual). "
-            "Currently this requires enable-tpl-model as a prerequisite.");
-static const arg_def_t deltalf_mode = ARG_DEF(
-    NULL, "delta-lf-mode", 1, "Enable delta-lf-mode (0: off (default), 1: on)");
-static const arg_def_t frame_periodic_boost =
-    ARG_DEF(NULL, "frame-boost", 1,
-            "Enable frame periodic boost (0: off (default), 1: on)");
-static const arg_def_t gf_cbr_boost_pct = ARG_DEF(
-    NULL, "gf-cbr-boost", 1, "Boost for Golden Frame in CBR mode (pct)");
-static const arg_def_t max_inter_rate_pct =
-    ARG_DEF(NULL, "max-inter-rate", 1, "Max P-frame bitrate (pct)");
-static const arg_def_t min_gf_interval = ARG_DEF(
-    NULL, "min-gf-interval", 1,
-    "min gf/arf frame interval (default 0, indicating in-built behavior)");
-static const arg_def_t max_gf_interval = ARG_DEF(
-    NULL, "max-gf-interval", 1,
-    "max gf/arf frame interval (default 0, indicating in-built behavior)");
-static const arg_def_t gf_min_pyr_height =
-    ARG_DEF(NULL, "gf-min-pyr-height", 1,
-            "Min height for GF group pyramid structure (0 (default) to 5)");
-static const arg_def_t gf_max_pyr_height =
-    ARG_DEF(NULL, "gf-max-pyr-height", 1,
-            "maximum height for GF group pyramid structure (0 to 5 (default))");
-static const arg_def_t max_reference_frames = ARG_DEF(
-    NULL, "max-reference-frames", 1,
-    "maximum number of reference frames allowed per frame (3 to 7 (default))");
-static const arg_def_t reduced_reference_set =
-    ARG_DEF(NULL, "reduced-reference-set", 1,
-            "Use reduced set of single and compound references (0: off "
-            "(default), 1: on)");
-static const arg_def_t target_seq_level_idx =
-    ARG_DEF(NULL, "target-seq-level-idx", 1,
-            "Target sequence level index. "
-            "Possible values are in the form of \"ABxy\"(pad leading zeros if "
-            "less than 4 digits). "
-            "AB: Operating point(OP) index; "
-            "xy: Target level index for the OP. "
-            "E.g. \"0\" means target level index 0 for the 0th OP; "
-            "\"1021\" means target level index 21 for the 10th OP.");
-static const arg_def_t set_min_cr =
-    ARG_DEF(NULL, "min-cr", 1,
-            "Set minimum compression ratio. Take integer values. Default is 0. "
-            "If non-zero, encoder will try to keep the compression ratio of "
-            "each frame to be higher than the given value divided by 100.");
-
-static const struct arg_enum_list color_primaries_enum[] = {
-  { "bt709", AOM_CICP_CP_BT_709 },
-  { "unspecified", AOM_CICP_CP_UNSPECIFIED },
-  { "bt601", AOM_CICP_CP_BT_601 },
-  { "bt470m", AOM_CICP_CP_BT_470_M },
-  { "bt470bg", AOM_CICP_CP_BT_470_B_G },
-  { "smpte240", AOM_CICP_CP_SMPTE_240 },
-  { "film", AOM_CICP_CP_GENERIC_FILM },
-  { "bt2020", AOM_CICP_CP_BT_2020 },
-  { "xyz", AOM_CICP_CP_XYZ },
-  { "smpte431", AOM_CICP_CP_SMPTE_431 },
-  { "smpte432", AOM_CICP_CP_SMPTE_432 },
-  { "ebu3213", AOM_CICP_CP_EBU_3213 },
-  { NULL, 0 }
-};
-
-static const arg_def_t input_color_primaries = ARG_DEF_ENUM(
-    NULL, "color-primaries", 1,
-    "Color primaries (CICP) of input content:", color_primaries_enum);
-
-static const struct arg_enum_list transfer_characteristics_enum[] = {
-  { "unspecified", AOM_CICP_CP_UNSPECIFIED },
-  { "bt709", AOM_CICP_TC_BT_709 },
-  { "bt470m", AOM_CICP_TC_BT_470_M },
-  { "bt470bg", AOM_CICP_TC_BT_470_B_G },
-  { "bt601", AOM_CICP_TC_BT_601 },
-  { "smpte240", AOM_CICP_TC_SMPTE_240 },
-  { "lin", AOM_CICP_TC_LINEAR },
-  { "log100", AOM_CICP_TC_LOG_100 },
-  { "log100sq10", AOM_CICP_TC_LOG_100_SQRT10 },
-  { "iec61966", AOM_CICP_TC_IEC_61966 },
-  { "bt1361", AOM_CICP_TC_BT_1361 },
-  { "srgb", AOM_CICP_TC_SRGB },
-  { "bt2020-10bit", AOM_CICP_TC_BT_2020_10_BIT },
-  { "bt2020-12bit", AOM_CICP_TC_BT_2020_12_BIT },
-  { "smpte2084", AOM_CICP_TC_SMPTE_2084 },
-  { "hlg", AOM_CICP_TC_HLG },
-  { "smpte428", AOM_CICP_TC_SMPTE_428 },
-  { NULL, 0 }
-};
-
-static const arg_def_t input_transfer_characteristics =
-    ARG_DEF_ENUM(NULL, "transfer-characteristics", 1,
-                 "Transfer characteristics (CICP) of input content:",
-                 transfer_characteristics_enum);
-
-static const struct arg_enum_list matrix_coefficients_enum[] = {
-  { "identity", AOM_CICP_MC_IDENTITY },
-  { "bt709", AOM_CICP_MC_BT_709 },
-  { "unspecified", AOM_CICP_MC_UNSPECIFIED },
-  { "fcc73", AOM_CICP_MC_FCC },
-  { "bt470bg", AOM_CICP_MC_BT_470_B_G },
-  { "bt601", AOM_CICP_MC_BT_601 },
-  { "smpte240", AOM_CICP_CP_SMPTE_240 },
-  { "ycgco", AOM_CICP_MC_SMPTE_YCGCO },
-  { "bt2020ncl", AOM_CICP_MC_BT_2020_NCL },
-  { "bt2020cl", AOM_CICP_MC_BT_2020_CL },
-  { "smpte2085", AOM_CICP_MC_SMPTE_2085 },
-  { "chromncl", AOM_CICP_MC_CHROMAT_NCL },
-  { "chromcl", AOM_CICP_MC_CHROMAT_CL },
-  { "ictcp", AOM_CICP_MC_ICTCP },
-  { NULL, 0 }
-};
-
-static const arg_def_t input_matrix_coefficients = ARG_DEF_ENUM(
-    NULL, "matrix-coefficients", 1,
-    "Matrix coefficients (CICP) of input content:", matrix_coefficients_enum);
-
-static const struct arg_enum_list chroma_sample_position_enum[] = {
-  { "unknown", AOM_CSP_UNKNOWN },
-  { "vertical", AOM_CSP_VERTICAL },
-  { "colocated", AOM_CSP_COLOCATED },
-  { NULL, 0 }
-};
-
-static const arg_def_t input_chroma_sample_position =
-    ARG_DEF_ENUM(NULL, "chroma-sample-position", 1,
-                 "The chroma sample position when chroma 4:2:0 is signaled:",
-                 chroma_sample_position_enum);
-
-static const struct arg_enum_list tune_content_enum[] = {
-  { "default", AOM_CONTENT_DEFAULT },
-  { "screen", AOM_CONTENT_SCREEN },
-  { NULL, 0 }
-};
-
-static const arg_def_t tune_content = ARG_DEF_ENUM(
-    NULL, "tune-content", 1, "Tune content type", tune_content_enum);
-
-static const arg_def_t cdf_update_mode =
-    ARG_DEF(NULL, "cdf-update-mode", 1,
-            "CDF update mode for entropy coding "
-            "(0: no CDF update; 1: update CDF on all frames(default); "
-            "2: selectively update CDF on some frames");
-
-static const struct arg_enum_list superblock_size_enum[] = {
-  { "dynamic", AOM_SUPERBLOCK_SIZE_DYNAMIC },
-  { "64", AOM_SUPERBLOCK_SIZE_64X64 },
-  { "128", AOM_SUPERBLOCK_SIZE_128X128 },
-  { NULL, 0 }
-};
-static const arg_def_t superblock_size = ARG_DEF_ENUM(
-    NULL, "sb-size", 1, "Superblock size to use", superblock_size_enum);
-
-static const arg_def_t set_tier_mask =
-    ARG_DEF(NULL, "set-tier-mask", 1,
-            "Set bit mask to specify which tier each of the 32 possible "
-            "operating points conforms to. "
-            "Bit value 0(defualt): Main Tier; 1: High Tier.");
-
-static const arg_def_t use_fixed_qp_offsets =
-    ARG_DEF(NULL, "use-fixed-qp-offsets", 1,
-            "Enable fixed QP offsets for frames at different levels of the "
-            "pyramid. Selected automatically from --cq-level if "
-            "--fixed-qp-offsets is not provided. If this option is not "
-            "specified (default), offsets are adaptively chosen by the "
-            "encoder.");
-
-static const arg_def_t fixed_qp_offsets =
-    ARG_DEF(NULL, "fixed-qp-offsets", 1,
-            "Set fixed QP offsets for frames at different levels of the "
-            "pyramid. Comma-separated list of 5 offsets for keyframe, ALTREF, "
-            "and 3 levels of internal alt-refs. If this option is not "
-            "specified (default), offsets are adaptively chosen by the "
-            "encoder.");
-
-static const arg_def_t vbr_corpus_complexity_lap = ARG_DEF(
-    NULL, "vbr-corpus-complexity-lap", 1,
-    "Set average corpus complexity per mb for single pass VBR using lap. "
-    "(0..10000), default is 0");
-
-static const arg_def_t *av1_args[] = { &cpu_used_av1,
-                                       &auto_altref,
-                                       &sharpness,
-                                       &static_thresh,
-                                       &rowmtarg,
-                                       &tile_cols,
-                                       &tile_rows,
-                                       &enable_tpl_model,
-                                       &enable_keyframe_filtering,
-                                       &arnr_maxframes,
-                                       &arnr_strength,
-                                       &tune_metric,
-                                       &cq_level,
-                                       &max_intra_rate_pct,
-                                       &max_inter_rate_pct,
-                                       &gf_cbr_boost_pct,
-                                       &lossless,
-                                       &enable_cdef,
-                                       &enable_restoration,
-                                       &enable_rect_partitions,
-                                       &enable_ab_partitions,
-                                       &enable_1to4_partitions,
-                                       &min_partition_size,
-                                       &max_partition_size,
-                                       &enable_dual_filter,
-                                       &enable_chroma_deltaq,
-                                       &enable_intra_edge_filter,
-                                       &enable_order_hint,
-                                       &enable_tx64,
-                                       &enable_flip_idtx,
-                                       &enable_rect_tx,
-                                       &enable_dist_wtd_comp,
-                                       &enable_masked_comp,
-                                       &enable_onesided_comp,
-                                       &enable_interintra_comp,
-                                       &enable_smooth_interintra,
-                                       &enable_diff_wtd_comp,
-                                       &enable_interinter_wedge,
-                                       &enable_interintra_wedge,
-                                       &enable_global_motion,
-                                       &enable_warped_motion,
-                                       &enable_filter_intra,
-                                       &enable_smooth_intra,
-                                       &enable_paeth_intra,
-                                       &enable_cfl_intra,
-                                       &force_video_mode,
-                                       &enable_obmc,
-                                       &enable_overlay,
-                                       &enable_palette,
-                                       &enable_intrabc,
-                                       &enable_angle_delta,
-                                       &disable_trellis_quant,
-                                       &enable_qm,
-                                       &qm_min,
-                                       &qm_max,
-                                       &reduced_tx_type_set,
-                                       &use_intra_dct_only,
-                                       &use_inter_dct_only,
-                                       &use_intra_default_tx_only,
-                                       &quant_b_adapt,
-                                       &coeff_cost_upd_freq,
-                                       &mode_cost_upd_freq,
-                                       &mv_cost_upd_freq,
-                                       &frame_parallel_decoding,
-                                       &error_resilient_mode,
-                                       &aq_mode,
-                                       &deltaq_mode,
-                                       &deltalf_mode,
-                                       &frame_periodic_boost,
-                                       &noise_sens,
-                                       &tune_content,
-                                       &cdf_update_mode,
-                                       &input_color_primaries,
-                                       &input_transfer_characteristics,
-                                       &input_matrix_coefficients,
-                                       &input_chroma_sample_position,
-                                       &min_gf_interval,
-                                       &max_gf_interval,
-                                       &gf_min_pyr_height,
-                                       &gf_max_pyr_height,
-                                       &superblock_size,
-                                       &num_tg,
-                                       &mtu_size,
-                                       &timing_info,
-                                       &film_grain_test,
-                                       &film_grain_table,
-#if CONFIG_DENOISE
-                                       &denoise_noise_level,
-                                       &denoise_block_size,
-#endif  // CONFIG_DENOISE
-                                       &max_reference_frames,
-                                       &reduced_reference_set,
-                                       &enable_ref_frame_mvs,
-                                       &target_seq_level_idx,
-                                       &set_tier_mask,
-                                       &set_min_cr,
-                                       &vbr_corpus_complexity_lap,
-                                       &bitdeptharg,
-                                       &inbitdeptharg,
-                                       &input_chroma_subsampling_x,
-                                       &input_chroma_subsampling_y,
-                                       &sframe_dist,
-                                       &sframe_mode,
-                                       &save_as_annexb,
-#if CONFIG_TUNE_VMAF
-                                       &vmaf_model_path,
-#endif
-                                       NULL };
 static const int av1_arg_ctrl_map[] = { AOME_SET_CPUUSED,
                                         AOME_SET_ENABLEAUTOALTREF,
                                         AOME_SET_SHARPNESS,
@@ -1042,7 +224,197 @@
                                         AV1E_SET_VMAF_MODEL_PATH,
 #endif
                                         0 };
-#endif  // CONFIG_AV1_ENCODER
+
+const arg_def_t *main_args[] = { &g_av1_codec_arg_defs.help,
+                                 &g_av1_codec_arg_defs.use_cfg,
+                                 &g_av1_codec_arg_defs.debugmode,
+                                 &g_av1_codec_arg_defs.outputfile,
+                                 &g_av1_codec_arg_defs.codecarg,
+                                 &g_av1_codec_arg_defs.passes,
+                                 &g_av1_codec_arg_defs.pass_arg,
+                                 &g_av1_codec_arg_defs.fpf_name,
+                                 &g_av1_codec_arg_defs.limit,
+                                 &g_av1_codec_arg_defs.skip,
+                                 &g_av1_codec_arg_defs.good_dl,
+                                 &g_av1_codec_arg_defs.rt_dl,
+                                 &g_av1_codec_arg_defs.quietarg,
+                                 &g_av1_codec_arg_defs.verbosearg,
+                                 &g_av1_codec_arg_defs.psnrarg,
+                                 &g_av1_codec_arg_defs.use_webm,
+                                 &g_av1_codec_arg_defs.use_ivf,
+                                 &g_av1_codec_arg_defs.use_obu,
+                                 &g_av1_codec_arg_defs.q_hist_n,
+                                 &g_av1_codec_arg_defs.rate_hist_n,
+                                 &g_av1_codec_arg_defs.disable_warnings,
+                                 &g_av1_codec_arg_defs.disable_warning_prompt,
+                                 &g_av1_codec_arg_defs.recontest,
+                                 NULL };
+
+const arg_def_t *global_args[] = {
+  &g_av1_codec_arg_defs.use_yv12,
+  &g_av1_codec_arg_defs.use_i420,
+  &g_av1_codec_arg_defs.use_i422,
+  &g_av1_codec_arg_defs.use_i444,
+  &g_av1_codec_arg_defs.usage,
+  &g_av1_codec_arg_defs.threads,
+  &g_av1_codec_arg_defs.profile,
+  &g_av1_codec_arg_defs.width,
+  &g_av1_codec_arg_defs.height,
+  &g_av1_codec_arg_defs.forced_max_frame_width,
+  &g_av1_codec_arg_defs.forced_max_frame_height,
+#if CONFIG_WEBM_IO
+  &g_av1_codec_arg_defs.stereo_mode,
+#endif
+  &g_av1_codec_arg_defs.timebase,
+  &g_av1_codec_arg_defs.framerate,
+  &g_av1_codec_arg_defs.global_error_resilient,
+  &g_av1_codec_arg_defs.bitdeptharg,
+  &g_av1_codec_arg_defs.lag_in_frames,
+  &g_av1_codec_arg_defs.large_scale_tile,
+  &g_av1_codec_arg_defs.monochrome,
+  &g_av1_codec_arg_defs.full_still_picture_hdr,
+  &g_av1_codec_arg_defs.use_16bit_internal,
+  NULL
+};
+
+const arg_def_t *rc_args[] = { &g_av1_codec_arg_defs.dropframe_thresh,
+                               &g_av1_codec_arg_defs.resize_mode,
+                               &g_av1_codec_arg_defs.resize_denominator,
+                               &g_av1_codec_arg_defs.resize_kf_denominator,
+                               &g_av1_codec_arg_defs.superres_mode,
+                               &g_av1_codec_arg_defs.superres_denominator,
+                               &g_av1_codec_arg_defs.superres_kf_denominator,
+                               &g_av1_codec_arg_defs.superres_qthresh,
+                               &g_av1_codec_arg_defs.superres_kf_qthresh,
+                               &g_av1_codec_arg_defs.end_usage,
+                               &g_av1_codec_arg_defs.target_bitrate,
+                               &g_av1_codec_arg_defs.min_quantizer,
+                               &g_av1_codec_arg_defs.max_quantizer,
+                               &g_av1_codec_arg_defs.undershoot_pct,
+                               &g_av1_codec_arg_defs.overshoot_pct,
+                               &g_av1_codec_arg_defs.buf_sz,
+                               &g_av1_codec_arg_defs.buf_initial_sz,
+                               &g_av1_codec_arg_defs.buf_optimal_sz,
+                               &g_av1_codec_arg_defs.bias_pct,
+                               &g_av1_codec_arg_defs.minsection_pct,
+                               &g_av1_codec_arg_defs.maxsection_pct,
+                               NULL };
+
+const arg_def_t *kf_args[] = { &g_av1_codec_arg_defs.fwd_kf_enabled,
+                               &g_av1_codec_arg_defs.kf_min_dist,
+                               &g_av1_codec_arg_defs.kf_max_dist,
+                               &g_av1_codec_arg_defs.kf_disabled, NULL };
+
+const arg_def_t *av1_args[] = {
+  &g_av1_codec_arg_defs.cpu_used_av1,
+  &g_av1_codec_arg_defs.auto_altref,
+  &g_av1_codec_arg_defs.sharpness,
+  &g_av1_codec_arg_defs.static_thresh,
+  &g_av1_codec_arg_defs.rowmtarg,
+  &g_av1_codec_arg_defs.tile_cols,
+  &g_av1_codec_arg_defs.tile_rows,
+  &g_av1_codec_arg_defs.enable_tpl_model,
+  &g_av1_codec_arg_defs.enable_keyframe_filtering,
+  &g_av1_codec_arg_defs.arnr_maxframes,
+  &g_av1_codec_arg_defs.arnr_strength,
+  &g_av1_codec_arg_defs.tune_metric,
+  &g_av1_codec_arg_defs.cq_level,
+  &g_av1_codec_arg_defs.max_intra_rate_pct,
+  &g_av1_codec_arg_defs.max_inter_rate_pct,
+  &g_av1_codec_arg_defs.gf_cbr_boost_pct,
+  &g_av1_codec_arg_defs.lossless,
+  &g_av1_codec_arg_defs.enable_cdef,
+  &g_av1_codec_arg_defs.enable_restoration,
+  &g_av1_codec_arg_defs.enable_rect_partitions,
+  &g_av1_codec_arg_defs.enable_ab_partitions,
+  &g_av1_codec_arg_defs.enable_1to4_partitions,
+  &g_av1_codec_arg_defs.min_partition_size,
+  &g_av1_codec_arg_defs.max_partition_size,
+  &g_av1_codec_arg_defs.enable_dual_filter,
+  &g_av1_codec_arg_defs.enable_chroma_deltaq,
+  &g_av1_codec_arg_defs.enable_intra_edge_filter,
+  &g_av1_codec_arg_defs.enable_order_hint,
+  &g_av1_codec_arg_defs.enable_tx64,
+  &g_av1_codec_arg_defs.enable_flip_idtx,
+  &g_av1_codec_arg_defs.enable_rect_tx,
+  &g_av1_codec_arg_defs.enable_dist_wtd_comp,
+  &g_av1_codec_arg_defs.enable_masked_comp,
+  &g_av1_codec_arg_defs.enable_onesided_comp,
+  &g_av1_codec_arg_defs.enable_interintra_comp,
+  &g_av1_codec_arg_defs.enable_smooth_interintra,
+  &g_av1_codec_arg_defs.enable_diff_wtd_comp,
+  &g_av1_codec_arg_defs.enable_interinter_wedge,
+  &g_av1_codec_arg_defs.enable_interintra_wedge,
+  &g_av1_codec_arg_defs.enable_global_motion,
+  &g_av1_codec_arg_defs.enable_warped_motion,
+  &g_av1_codec_arg_defs.enable_filter_intra,
+  &g_av1_codec_arg_defs.enable_smooth_intra,
+  &g_av1_codec_arg_defs.enable_paeth_intra,
+  &g_av1_codec_arg_defs.enable_cfl_intra,
+  &g_av1_codec_arg_defs.force_video_mode,
+  &g_av1_codec_arg_defs.enable_obmc,
+  &g_av1_codec_arg_defs.enable_overlay,
+  &g_av1_codec_arg_defs.enable_palette,
+  &g_av1_codec_arg_defs.enable_intrabc,
+  &g_av1_codec_arg_defs.enable_angle_delta,
+  &g_av1_codec_arg_defs.disable_trellis_quant,
+  &g_av1_codec_arg_defs.enable_qm,
+  &g_av1_codec_arg_defs.qm_min,
+  &g_av1_codec_arg_defs.qm_max,
+  &g_av1_codec_arg_defs.reduced_tx_type_set,
+  &g_av1_codec_arg_defs.use_intra_dct_only,
+  &g_av1_codec_arg_defs.use_inter_dct_only,
+  &g_av1_codec_arg_defs.use_intra_default_tx_only,
+  &g_av1_codec_arg_defs.quant_b_adapt,
+  &g_av1_codec_arg_defs.coeff_cost_upd_freq,
+  &g_av1_codec_arg_defs.mode_cost_upd_freq,
+  &g_av1_codec_arg_defs.mv_cost_upd_freq,
+  &g_av1_codec_arg_defs.frame_parallel_decoding,
+  &g_av1_codec_arg_defs.error_resilient_mode,
+  &g_av1_codec_arg_defs.aq_mode,
+  &g_av1_codec_arg_defs.deltaq_mode,
+  &g_av1_codec_arg_defs.deltalf_mode,
+  &g_av1_codec_arg_defs.frame_periodic_boost,
+  &g_av1_codec_arg_defs.noise_sens,
+  &g_av1_codec_arg_defs.tune_content,
+  &g_av1_codec_arg_defs.cdf_update_mode,
+  &g_av1_codec_arg_defs.input_color_primaries,
+  &g_av1_codec_arg_defs.input_transfer_characteristics,
+  &g_av1_codec_arg_defs.input_matrix_coefficients,
+  &g_av1_codec_arg_defs.input_chroma_sample_position,
+  &g_av1_codec_arg_defs.min_gf_interval,
+  &g_av1_codec_arg_defs.max_gf_interval,
+  &g_av1_codec_arg_defs.gf_min_pyr_height,
+  &g_av1_codec_arg_defs.gf_max_pyr_height,
+  &g_av1_codec_arg_defs.superblock_size,
+  &g_av1_codec_arg_defs.num_tg,
+  &g_av1_codec_arg_defs.mtu_size,
+  &g_av1_codec_arg_defs.timing_info,
+  &g_av1_codec_arg_defs.film_grain_test,
+  &g_av1_codec_arg_defs.film_grain_table,
+#if CONFIG_DENOISE
+  &g_av1_codec_arg_defs.denoise_noise_level,
+  &g_av1_codec_arg_defs.denoise_block_size,
+#endif  // CONFIG_DENOISE
+  &g_av1_codec_arg_defs.max_reference_frames,
+  &g_av1_codec_arg_defs.reduced_reference_set,
+  &g_av1_codec_arg_defs.enable_ref_frame_mvs,
+  &g_av1_codec_arg_defs.target_seq_level_idx,
+  &g_av1_codec_arg_defs.set_tier_mask,
+  &g_av1_codec_arg_defs.set_min_cr,
+  &g_av1_codec_arg_defs.vbr_corpus_complexity_lap,
+  &g_av1_codec_arg_defs.bitdeptharg,
+  &g_av1_codec_arg_defs.inbitdeptharg,
+  &g_av1_codec_arg_defs.input_chroma_subsampling_x,
+  &g_av1_codec_arg_defs.input_chroma_subsampling_y,
+  &g_av1_codec_arg_defs.sframe_dist,
+  &g_av1_codec_arg_defs.sframe_mode,
+  &g_av1_codec_arg_defs.save_as_annexb,
+#if CONFIG_TUNE_VMAF
+  &g_av1_codec_arg_defs.vmaf_model_path,
+#endif
+  NULL
+};
 
 static const arg_def_t *no_args[] = { NULL };
 
@@ -1186,77 +558,81 @@
   for (argi = argj = argv_local; (*argj = *argi); argi += arg.argv_step) {
     arg.argv_step = 1;
 
-    if (arg_match(&arg, &use_cfg, argi)) {
+    if (arg_match(&arg, &g_av1_codec_arg_defs.use_cfg, argi)) {
       if (!cfg_included) {
         parse_cfg(arg.val, &global->encoder_config);
         cfg_included = 1;
       }
-    } else if (arg_match(&arg, &help, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.help, argi)) {
       show_help(stdout, 0);
       exit(EXIT_SUCCESS);
-    } else if (arg_match(&arg, &codecarg, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.codecarg, argi)) {
       global->codec = get_aom_encoder_by_short_name(arg.val);
       if (!global->codec)
         die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
-    } else if (arg_match(&arg, &passes, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.passes, argi)) {
       global->passes = arg_parse_uint(&arg);
 
       if (global->passes < 1 || global->passes > 2)
         die("Error: Invalid number of passes (%d)\n", global->passes);
-    } else if (arg_match(&arg, &pass_arg, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.pass_arg, argi)) {
       global->pass = arg_parse_uint(&arg);
 
       if (global->pass < 1 || global->pass > 2)
         die("Error: Invalid pass selected (%d)\n", global->pass);
-    } else if (arg_match(&arg, &input_chroma_sample_position, argi)) {
+    } else if (arg_match(&arg,
+                         &g_av1_codec_arg_defs.input_chroma_sample_position,
+                         argi)) {
       global->csp = arg_parse_enum(&arg);
       /* Flag is used by later code as well, preserve it. */
       argj++;
-    } else if (arg_match(&arg, &usage, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.usage, argi)) {
       global->usage = arg_parse_uint(&arg);
-    else if (arg_match(&arg, &good_dl, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.good_dl, argi)) {
       global->usage = AOM_USAGE_GOOD_QUALITY;  // Good quality usage
-    else if (arg_match(&arg, &rt_dl, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.rt_dl, argi)) {
       global->usage = AOM_USAGE_REALTIME;  // Real-time usage
-    else if (arg_match(&arg, &use_yv12, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_yv12, argi)) {
       global->color_type = YV12;
-    else if (arg_match(&arg, &use_i420, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_i420, argi)) {
       global->color_type = I420;
-    else if (arg_match(&arg, &use_i422, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_i422, argi)) {
       global->color_type = I422;
-    else if (arg_match(&arg, &use_i444, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_i444, argi)) {
       global->color_type = I444;
-    else if (arg_match(&arg, &quietarg, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.quietarg, argi)) {
       global->quiet = 1;
-    else if (arg_match(&arg, &verbosearg, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.verbosearg, argi)) {
       global->verbose = 1;
-    else if (arg_match(&arg, &limit, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.limit, argi)) {
       global->limit = arg_parse_uint(&arg);
-    else if (arg_match(&arg, &skip, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.skip, argi)) {
       global->skip_frames = arg_parse_uint(&arg);
-    else if (arg_match(&arg, &psnrarg, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.psnrarg, argi)) {
       if (arg.val)
         global->show_psnr = arg_parse_int(&arg);
       else
         global->show_psnr = 1;
-    } else if (arg_match(&arg, &recontest, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.recontest, argi)) {
       global->test_decode = arg_parse_enum_or_int(&arg);
-    } else if (arg_match(&arg, &framerate, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.framerate, argi)) {
       global->framerate = arg_parse_rational(&arg);
       validate_positive_rational(arg.name, &global->framerate);
       global->have_framerate = 1;
-    } else if (arg_match(&arg, &debugmode, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.debugmode, argi)) {
       global->debug = 1;
-    else if (arg_match(&arg, &q_hist_n, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.q_hist_n, argi)) {
       global->show_q_hist_buckets = arg_parse_uint(&arg);
-    else if (arg_match(&arg, &rate_hist_n, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.rate_hist_n, argi)) {
       global->show_rate_hist_buckets = arg_parse_uint(&arg);
-    else if (arg_match(&arg, &disable_warnings, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.disable_warnings, argi)) {
       global->disable_warnings = 1;
-    else if (arg_match(&arg, &disable_warning_prompt, argi))
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.disable_warning_prompt,
+                         argi)) {
       global->disable_warning_prompt = 1;
-    else
+    } else {
       argj++;
+    }
   }
 
   if (global->pass) {
@@ -1469,7 +845,7 @@
       continue;
     }
 
-    if (arg_match(&arg, &outputfile, argi)) {
+    if (arg_match(&arg, &g_av1_codec_arg_defs.outputfile, argi)) {
       config->out_fn = arg.val;
       if (!webm_forced) {
         const size_t out_fn_len = strlen(config->out_fn);
@@ -1483,143 +859,156 @@
           config->write_ivf = 0;
         }
       }
-    } else if (arg_match(&arg, &fpf_name, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.fpf_name, argi)) {
       config->stats_fn = arg.val;
-    } else if (arg_match(&arg, &use_webm, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_webm, argi)) {
 #if CONFIG_WEBM_IO
       config->write_webm = 1;
       webm_forced = 1;
 #else
       die("Error: --webm specified but webm is disabled.");
 #endif
-    } else if (arg_match(&arg, &use_ivf, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_ivf, argi)) {
       config->write_webm = 0;
       config->write_ivf = 1;
-    } else if (arg_match(&arg, &use_obu, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_obu, argi)) {
       config->write_webm = 0;
       config->write_ivf = 0;
-    } else if (arg_match(&arg, &threads, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.threads, argi)) {
       config->cfg.g_threads = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &profile, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.profile, argi)) {
       config->cfg.g_profile = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &width, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.width, argi)) {
       config->cfg.g_w = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &height, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.height, argi)) {
       config->cfg.g_h = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &forced_max_frame_width, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.forced_max_frame_width,
+                         argi)) {
       config->cfg.g_forced_max_frame_width = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &forced_max_frame_height, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.forced_max_frame_height,
+                         argi)) {
       config->cfg.g_forced_max_frame_height = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &bitdeptharg, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.bitdeptharg, argi)) {
       config->cfg.g_bit_depth = arg_parse_enum_or_int(&arg);
-    } else if (arg_match(&arg, &inbitdeptharg, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.inbitdeptharg, argi)) {
       config->cfg.g_input_bit_depth = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &input_chroma_subsampling_x, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.input_chroma_subsampling_x,
+                         argi)) {
       stream->chroma_subsampling_x = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &input_chroma_subsampling_y, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.input_chroma_subsampling_y,
+                         argi)) {
       stream->chroma_subsampling_y = arg_parse_uint(&arg);
 #if CONFIG_WEBM_IO
-    } else if (arg_match(&arg, &stereo_mode, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.stereo_mode, argi)) {
       config->stereo_fmt = arg_parse_enum_or_int(&arg);
 #endif
-    } else if (arg_match(&arg, &timebase, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.timebase, argi)) {
       config->cfg.g_timebase = arg_parse_rational(&arg);
       validate_positive_rational(arg.name, &config->cfg.g_timebase);
-    } else if (arg_match(&arg, &global_error_resilient, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.global_error_resilient,
+                         argi)) {
       config->cfg.g_error_resilient = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &lag_in_frames, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.lag_in_frames, argi)) {
       config->cfg.g_lag_in_frames = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &large_scale_tile, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.large_scale_tile, argi)) {
       config->cfg.large_scale_tile = arg_parse_uint(&arg);
       if (config->cfg.large_scale_tile) {
         global->codec = get_aom_encoder_by_short_name("av1");
       }
-    } else if (arg_match(&arg, &monochrome, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.monochrome, argi)) {
       config->cfg.monochrome = 1;
-    } else if (arg_match(&arg, &full_still_picture_hdr, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.full_still_picture_hdr,
+                         argi)) {
       config->cfg.full_still_picture_hdr = 1;
-    } else if (arg_match(&arg, &use_16bit_internal, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_16bit_internal,
+                         argi)) {
       config->use_16bit_internal = CONFIG_AV1_HIGHBITDEPTH;
       if (!config->use_16bit_internal) {
         warn("%s option ignored with CONFIG_AV1_HIGHBITDEPTH=0.\n", arg.name);
       }
-    } else if (arg_match(&arg, &dropframe_thresh, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.dropframe_thresh, argi)) {
       config->cfg.rc_dropframe_thresh = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &resize_mode, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.resize_mode, argi)) {
       config->cfg.rc_resize_mode = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &resize_denominator, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.resize_denominator,
+                         argi)) {
       config->cfg.rc_resize_denominator = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &resize_kf_denominator, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.resize_kf_denominator,
+                         argi)) {
       config->cfg.rc_resize_kf_denominator = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &superres_mode, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.superres_mode, argi)) {
       config->cfg.rc_superres_mode = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &superres_denominator, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.superres_denominator,
+                         argi)) {
       config->cfg.rc_superres_denominator = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &superres_kf_denominator, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.superres_kf_denominator,
+                         argi)) {
       config->cfg.rc_superres_kf_denominator = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &superres_qthresh, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.superres_qthresh, argi)) {
       config->cfg.rc_superres_qthresh = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &superres_kf_qthresh, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.superres_kf_qthresh,
+                         argi)) {
       config->cfg.rc_superres_kf_qthresh = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &end_usage, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.end_usage, argi)) {
       config->cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
-    } else if (arg_match(&arg, &target_bitrate, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.target_bitrate, argi)) {
       config->cfg.rc_target_bitrate = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &min_quantizer, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.min_quantizer, argi)) {
       config->cfg.rc_min_quantizer = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &max_quantizer, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.max_quantizer, argi)) {
       config->cfg.rc_max_quantizer = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &undershoot_pct, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.undershoot_pct, argi)) {
       config->cfg.rc_undershoot_pct = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &overshoot_pct, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.overshoot_pct, argi)) {
       config->cfg.rc_overshoot_pct = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &buf_sz, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.buf_sz, argi)) {
       config->cfg.rc_buf_sz = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &buf_initial_sz, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.buf_initial_sz, argi)) {
       config->cfg.rc_buf_initial_sz = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &buf_optimal_sz, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.buf_optimal_sz, argi)) {
       config->cfg.rc_buf_optimal_sz = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &bias_pct, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.bias_pct, argi)) {
       config->cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);
       if (global->passes < 2)
         warn("option %s ignored in one-pass mode.\n", arg.name);
-    } else if (arg_match(&arg, &minsection_pct, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.minsection_pct, argi)) {
       config->cfg.rc_2pass_vbr_minsection_pct = arg_parse_uint(&arg);
 
       if (global->passes < 2)
         warn("option %s ignored in one-pass mode.\n", arg.name);
-    } else if (arg_match(&arg, &maxsection_pct, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.maxsection_pct, argi)) {
       config->cfg.rc_2pass_vbr_maxsection_pct = arg_parse_uint(&arg);
 
       if (global->passes < 2)
         warn("option %s ignored in one-pass mode.\n", arg.name);
-    } else if (arg_match(&arg, &fwd_kf_enabled, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.fwd_kf_enabled, argi)) {
       config->cfg.fwd_kf_enabled = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &kf_min_dist, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.kf_min_dist, argi)) {
       config->cfg.kf_min_dist = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &kf_max_dist, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.kf_max_dist, argi)) {
       config->cfg.kf_max_dist = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &kf_disabled, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.kf_disabled, argi)) {
       config->cfg.kf_mode = AOM_KF_DISABLED;
-    } else if (arg_match(&arg, &sframe_dist, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.sframe_dist, argi)) {
       config->cfg.sframe_dist = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &sframe_mode, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.sframe_mode, argi)) {
       config->cfg.sframe_mode = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &save_as_annexb, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.save_as_annexb, argi)) {
       config->cfg.save_as_annexb = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &tile_width, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.tile_width, argi)) {
       config->cfg.tile_width_count =
           arg_parse_list(&arg, config->cfg.tile_widths, MAX_TILE_WIDTHS);
-    } else if (arg_match(&arg, &tile_height, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.tile_height, argi)) {
       config->cfg.tile_height_count =
           arg_parse_list(&arg, config->cfg.tile_heights, MAX_TILE_HEIGHTS);
 #if CONFIG_TUNE_VMAF
     } else if (arg_match(&arg, &vmaf_model_path, argi)) {
       config->vmaf_model_path = arg.val;
 #endif
-    } else if (arg_match(&arg, &use_fixed_qp_offsets, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_fixed_qp_offsets,
+                         argi)) {
       config->cfg.use_fixed_qp_offsets = arg_parse_uint(&arg);
-    } else if (arg_match(&arg, &fixed_qp_offsets, argi)) {
+    } else if (arg_match(&arg, &g_av1_codec_arg_defs.fixed_qp_offsets, argi)) {
       const int fixed_qp_offset_count = arg_parse_list(
           &arg, config->cfg.fixed_qp_offsets, FIXED_QP_OFFSET_COUNT);
       if (fixed_qp_offset_count < FIXED_QP_OFFSET_COUNT) {
@@ -1629,7 +1018,8 @@
       }
       config->cfg.use_fixed_qp_offsets = 1;
     } else if (global->usage == AOM_USAGE_REALTIME &&
-               arg_match(&arg, &enable_restoration, argi)) {
+               arg_match(&arg, &g_av1_codec_arg_defs.enable_restoration,
+                         argi)) {
       if (arg_parse_uint(&arg) == 1) {
         warn("non-zero %s option ignored in realtime mode.\n", arg.name);
       }
diff --git a/apps/aomenc.h b/apps/aomenc.h
index 8d4c25c..d717b24 100644
--- a/apps/aomenc.h
+++ b/apps/aomenc.h
@@ -13,17 +13,12 @@
 
 #include "aom/aom_codec.h"
 #include "aom/aom_encoder.h"
+#include "av1/arg_defs.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-enum TestDecodeFatality {
-  TEST_DECODE_OFF,
-  TEST_DECODE_FATAL,
-  TEST_DECODE_WARN,
-};
-
 typedef enum {
   I420,  // 4:2:0 8+ bit-depth
   I422,  // 4:2:2 8+ bit-depth
diff --git a/av1/arg_defs.c b/av1/arg_defs.c
new file mode 100644
index 0000000..b599c05
--- /dev/null
+++ b/av1/arg_defs.c
@@ -0,0 +1,598 @@
+/*
+ * Copyright (c) 2021, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#include "av1/arg_defs.h"
+
+static const struct arg_enum_list test_decode_enum[] = {
+  { "off", TEST_DECODE_OFF },
+  { "fatal", TEST_DECODE_FATAL },
+  { "warn", TEST_DECODE_WARN },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list bitdepth_enum[] = {
+  { "8", AOM_BITS_8 }, { "10", AOM_BITS_10 }, { "12", AOM_BITS_12 }, { NULL, 0 }
+};
+
+#if CONFIG_WEBM_IO
+static const struct arg_enum_list stereo_mode_enum[] = {
+  { "mono", STEREO_FORMAT_MONO },
+  { "left-right", STEREO_FORMAT_LEFT_RIGHT },
+  { "bottom-top", STEREO_FORMAT_BOTTOM_TOP },
+  { "top-bottom", STEREO_FORMAT_TOP_BOTTOM },
+  { "right-left", STEREO_FORMAT_RIGHT_LEFT },
+  { NULL, 0 }
+};
+#endif
+
+static const struct arg_enum_list end_usage_enum[] = { { "vbr", AOM_VBR },
+                                                       { "cbr", AOM_CBR },
+                                                       { "cq", AOM_CQ },
+                                                       { "q", AOM_Q },
+                                                       { NULL, 0 } };
+
+static const struct arg_enum_list tuning_enum[] = {
+  { "psnr", AOM_TUNE_PSNR },
+  { "ssim", AOM_TUNE_SSIM },
+  { "vmaf_with_preprocessing", AOM_TUNE_VMAF_WITH_PREPROCESSING },
+  { "vmaf_without_preprocessing", AOM_TUNE_VMAF_WITHOUT_PREPROCESSING },
+  { "vmaf", AOM_TUNE_VMAF_MAX_GAIN },
+  { "vmaf_neg", AOM_TUNE_VMAF_NEG_MAX_GAIN },
+  { NULL, 0 }
+};
+
+#if CONFIG_AV1_ENCODER
+static const struct arg_enum_list timing_info_enum[] = {
+  { "unspecified", AOM_TIMING_UNSPECIFIED },
+  { "constant", AOM_TIMING_EQUAL },
+  { "model", AOM_TIMING_DEC_MODEL },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list superblock_size_enum[] = {
+  { "dynamic", AOM_SUPERBLOCK_SIZE_DYNAMIC },
+  { "64", AOM_SUPERBLOCK_SIZE_64X64 },
+  { "128", AOM_SUPERBLOCK_SIZE_128X128 },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list matrix_coefficients_enum[] = {
+  { "identity", AOM_CICP_MC_IDENTITY },
+  { "bt709", AOM_CICP_MC_BT_709 },
+  { "unspecified", AOM_CICP_MC_UNSPECIFIED },
+  { "fcc73", AOM_CICP_MC_FCC },
+  { "bt470bg", AOM_CICP_MC_BT_470_B_G },
+  { "bt601", AOM_CICP_MC_BT_601 },
+  { "smpte240", AOM_CICP_CP_SMPTE_240 },
+  { "ycgco", AOM_CICP_MC_SMPTE_YCGCO },
+  { "bt2020ncl", AOM_CICP_MC_BT_2020_NCL },
+  { "bt2020cl", AOM_CICP_MC_BT_2020_CL },
+  { "smpte2085", AOM_CICP_MC_SMPTE_2085 },
+  { "chromncl", AOM_CICP_MC_CHROMAT_NCL },
+  { "chromcl", AOM_CICP_MC_CHROMAT_CL },
+  { "ictcp", AOM_CICP_MC_ICTCP },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list chroma_sample_position_enum[] = {
+  { "unknown", AOM_CSP_UNKNOWN },
+  { "vertical", AOM_CSP_VERTICAL },
+  { "colocated", AOM_CSP_COLOCATED },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list tune_content_enum[] = {
+  { "default", AOM_CONTENT_DEFAULT },
+  { "screen", AOM_CONTENT_SCREEN },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list transfer_characteristics_enum[] = {
+  { "unspecified", AOM_CICP_CP_UNSPECIFIED },
+  { "bt709", AOM_CICP_TC_BT_709 },
+  { "bt470m", AOM_CICP_TC_BT_470_M },
+  { "bt470bg", AOM_CICP_TC_BT_470_B_G },
+  { "bt601", AOM_CICP_TC_BT_601 },
+  { "smpte240", AOM_CICP_TC_SMPTE_240 },
+  { "lin", AOM_CICP_TC_LINEAR },
+  { "log100", AOM_CICP_TC_LOG_100 },
+  { "log100sq10", AOM_CICP_TC_LOG_100_SQRT10 },
+  { "iec61966", AOM_CICP_TC_IEC_61966 },
+  { "bt1361", AOM_CICP_TC_BT_1361 },
+  { "srgb", AOM_CICP_TC_SRGB },
+  { "bt2020-10bit", AOM_CICP_TC_BT_2020_10_BIT },
+  { "bt2020-12bit", AOM_CICP_TC_BT_2020_12_BIT },
+  { "smpte2084", AOM_CICP_TC_SMPTE_2084 },
+  { "hlg", AOM_CICP_TC_HLG },
+  { "smpte428", AOM_CICP_TC_SMPTE_428 },
+  { NULL, 0 }
+};
+
+static const struct arg_enum_list color_primaries_enum[] = {
+  { "bt709", AOM_CICP_CP_BT_709 },
+  { "unspecified", AOM_CICP_CP_UNSPECIFIED },
+  { "bt601", AOM_CICP_CP_BT_601 },
+  { "bt470m", AOM_CICP_CP_BT_470_M },
+  { "bt470bg", AOM_CICP_CP_BT_470_B_G },
+  { "smpte240", AOM_CICP_CP_SMPTE_240 },
+  { "film", AOM_CICP_CP_GENERIC_FILM },
+  { "bt2020", AOM_CICP_CP_BT_2020 },
+  { "xyz", AOM_CICP_CP_XYZ },
+  { "smpte431", AOM_CICP_CP_SMPTE_431 },
+  { "smpte432", AOM_CICP_CP_SMPTE_432 },
+  { "ebu3213", AOM_CICP_CP_EBU_3213 },
+  { NULL, 0 }
+};
+#endif  // CONFIG_AV1_ENCODER
+
+const av1_codec_arg_definitions_t g_av1_codec_arg_defs = {
+  .help = ARG_DEF(NULL, "help", 0, "Show usage options and exit"),
+  .debugmode =
+      ARG_DEF("D", "debug", 0, "Debug mode (makes output deterministic)"),
+  .outputfile = ARG_DEF("o", "output", 1, "Output filename"),
+  .use_yv12 = ARG_DEF(NULL, "yv12", 0, "Input file is YV12 "),
+  .use_i420 = ARG_DEF(NULL, "i420", 0, "Input file is I420 (default)"),
+  .use_i422 = ARG_DEF(NULL, "i422", 0, "Input file is I422"),
+  .use_i444 = ARG_DEF(NULL, "i444", 0, "Input file is I444"),
+  .codecarg = ARG_DEF(NULL, "codec", 1, "Codec to use"),
+  .passes = ARG_DEF("p", "passes", 1, "Number of passes (1/2)"),
+  .pass_arg = ARG_DEF(NULL, "pass", 1, "Pass to execute (1/2)"),
+  .fpf_name = ARG_DEF(NULL, "fpf", 1, "First pass statistics file name"),
+  .limit = ARG_DEF(NULL, "limit", 1, "Stop encoding after n input frames"),
+  .skip = ARG_DEF(NULL, "skip", 1, "Skip the first n input frames"),
+  .good_dl = ARG_DEF(NULL, "good", 0, "Use Good Quality Deadline"),
+  .rt_dl = ARG_DEF(NULL, "rt", 0, "Use Realtime Quality Deadline"),
+  .quietarg = ARG_DEF("q", "quiet", 0, "Do not print encode progress"),
+  .verbosearg = ARG_DEF("v", "verbose", 0, "Show encoder parameters"),
+  .psnrarg = ARG_DEF(
+      NULL, "psnr", -1,
+      "Show PSNR in status line"
+      "(0: Disable PSNR status line display, 1: PSNR calculated using input "
+      "bit-depth (default), 2: PSNR calculated using stream bit-depth), "
+      "takes default option when arguments are not specified"),
+  .use_cfg = ARG_DEF("c", "cfg", 1, "Config file to use"),
+  .recontest = ARG_DEF_ENUM(NULL, "test-decode", 1,
+                            "Test encode/decode mismatch", test_decode_enum),
+  .framerate = ARG_DEF(NULL, "fps", 1, "Stream frame rate (rate/scale)"),
+  .use_webm =
+      ARG_DEF(NULL, "webm", 0, "Output WebM (default when WebM IO is enabled)"),
+  .use_ivf = ARG_DEF(NULL, "ivf", 0, "Output IVF"),
+  .use_obu = ARG_DEF(NULL, "obu", 0, "Output OBU"),
+  .q_hist_n =
+      ARG_DEF(NULL, "q-hist", 1, "Show quantizer histogram (n-buckets)"),
+  .rate_hist_n =
+      ARG_DEF(NULL, "rate-hist", 1, "Show rate histogram (n-buckets)"),
+  .disable_warnings =
+      ARG_DEF(NULL, "disable-warnings", 0,
+              "Disable warnings about potentially incorrect encode settings."),
+  .disable_warning_prompt =
+      ARG_DEF("y", "disable-warning-prompt", 0,
+              "Display warnings, but do not prompt user to continue."),
+  .bitdeptharg = ARG_DEF_ENUM(
+      "b", "bit-depth", 1,
+      "Bit depth for codec (8 for version <=1, 10 or 12 for version 2)",
+      bitdepth_enum),
+  .inbitdeptharg = ARG_DEF(NULL, "input-bit-depth", 1, "Bit depth of input"),
+
+  .input_chroma_subsampling_x = ARG_DEF(NULL, "input-chroma-subsampling-x", 1,
+                                        "chroma subsampling x value."),
+  .input_chroma_subsampling_y = ARG_DEF(NULL, "input-chroma-subsampling-y", 1,
+                                        "chroma subsampling y value."),
+
+  .usage = ARG_DEF("u", "usage", 1, "Usage profile number to use"),
+  .threads = ARG_DEF("t", "threads", 1, "Max number of threads to use"),
+  .profile = ARG_DEF(NULL, "profile", 1, "Bitstream profile number to use"),
+  .width = ARG_DEF("w", "width", 1, "Frame width"),
+  .height = ARG_DEF("h", "height", 1, "Frame height"),
+  .forced_max_frame_width = ARG_DEF(NULL, "forced_max_frame_width", 1,
+                                    "Maximum frame width value to force"),
+  .forced_max_frame_height = ARG_DEF(NULL, "forced_max_frame_height", 1,
+                                     "Maximum frame height value to force"),
+#if CONFIG_WEBM_IO
+  .stereo_mode = ARG_DEF_ENUM(NULL, "stereo-mode", 1, "Stereo 3D video format",
+                              stereo_mode_enum),
+#endif
+  .timebase = ARG_DEF(NULL, "timebase", 1,
+                      "Output timestamp precision (fractional seconds)"),
+  .global_error_resilient = ARG_DEF(NULL, "global-error-resilient", 1,
+                                    "Enable global error resiliency features"),
+  .lag_in_frames =
+      ARG_DEF(NULL, "lag-in-frames", 1, "Max number of frames to lag"),
+  .large_scale_tile = ARG_DEF(
+      NULL, "large-scale-tile", 1,
+      "Large scale tile coding (0: off (default), 1: on (ivf output only))"),
+  .monochrome =
+      ARG_DEF(NULL, "monochrome", 0, "Monochrome video (no chroma planes)"),
+  .full_still_picture_hdr = ARG_DEF(NULL, "full-still-picture-hdr", 0,
+                                    "Use full header for still picture"),
+  .use_16bit_internal =
+      ARG_DEF(NULL, "use-16bit-internal", 0, "Force use of 16-bit pipeline"),
+  .dropframe_thresh =
+      ARG_DEF(NULL, "drop-frame", 1, "Temporal resampling threshold (buf %)"),
+  .resize_mode = ARG_DEF(NULL, "resize-mode", 1, "Frame resize mode"),
+  .resize_denominator =
+      ARG_DEF(NULL, "resize-denominator", 1, "Frame resize denominator"),
+  .resize_kf_denominator = ARG_DEF(NULL, "resize-kf-denominator", 1,
+                                   "Frame resize keyframe denominator"),
+  .superres_mode =
+      ARG_DEF(NULL, "superres-mode", 1, "Frame super-resolution mode"),
+  .superres_denominator = ARG_DEF(NULL, "superres-denominator", 1,
+                                  "Frame super-resolution denominator"),
+  .superres_kf_denominator =
+      ARG_DEF(NULL, "superres-kf-denominator", 1,
+              "Frame super-resolution keyframe denominator"),
+  .superres_qthresh = ARG_DEF(NULL, "superres-qthresh", 1,
+                              "Frame super-resolution qindex threshold"),
+  .superres_kf_qthresh =
+      ARG_DEF(NULL, "superres-kf-qthresh", 1,
+              "Frame super-resolution keyframe qindex threshold"),
+  .end_usage =
+      ARG_DEF_ENUM(NULL, "end-usage", 1, "Rate control mode", end_usage_enum),
+  .target_bitrate = ARG_DEF(NULL, "target-bitrate", 1, "Bitrate (kbps)"),
+  .min_quantizer = ARG_DEF(NULL, "min-q", 1, "Minimum (best) quantizer"),
+  .max_quantizer = ARG_DEF(NULL, "max-q", 1, "Maximum (worst) quantizer"),
+  .undershoot_pct = ARG_DEF(NULL, "undershoot-pct", 1,
+                            "Datarate undershoot (min) target (%)"),
+  .overshoot_pct =
+      ARG_DEF(NULL, "overshoot-pct", 1, "Datarate overshoot (max) target (%)"),
+  .buf_sz = ARG_DEF(NULL, "buf-sz", 1, "Client buffer size (ms)"),
+  .buf_initial_sz =
+      ARG_DEF(NULL, "buf-initial-sz", 1, "Client initial buffer size (ms)"),
+  .buf_optimal_sz =
+      ARG_DEF(NULL, "buf-optimal-sz", 1, "Client optimal buffer size (ms)"),
+  .bias_pct = ARG_DEF(NULL, "bias-pct", 1, "CBR/VBR bias (0=CBR, 100=VBR)"),
+  .minsection_pct =
+      ARG_DEF(NULL, "minsection-pct", 1, "GOP min bitrate (% of target)"),
+  .maxsection_pct =
+      ARG_DEF(NULL, "maxsection-pct", 1, "GOP max bitrate (% of target)"),
+  .fwd_kf_enabled =
+      ARG_DEF(NULL, "enable-fwd-kf", 1, "Enable forward reference keyframes"),
+  .kf_min_dist =
+      ARG_DEF(NULL, "kf-min-dist", 1, "Minimum keyframe interval (frames)"),
+  .kf_max_dist =
+      ARG_DEF(NULL, "kf-max-dist", 1, "Maximum keyframe interval (frames)"),
+  .kf_disabled = ARG_DEF(NULL, "disable-kf", 0, "Disable keyframe placement"),
+  .sframe_dist = ARG_DEF(NULL, "sframe-dist", 1, "S-Frame interval (frames)"),
+  .sframe_mode =
+      ARG_DEF(NULL, "sframe-mode", 1, "S-Frame insertion mode (1..2)"),
+  .save_as_annexb = ARG_DEF(NULL, "annexb", 1, "Save as Annex-B"),
+  .noise_sens = ARG_DEF(NULL, "noise-sensitivity", 1,
+                        "Noise sensitivity (frames to blur)"),
+  .sharpness = ARG_DEF(NULL, "sharpness", 1,
+                       "Loop filter sharpness (0..7), default is 0"),
+  .static_thresh =
+      ARG_DEF(NULL, "static-thresh", 1, "Motion detection threshold"),
+  .auto_altref =
+      ARG_DEF(NULL, "auto-alt-ref", 1, "Enable automatic alt reference frames"),
+  .arnr_maxframes =
+      ARG_DEF(NULL, "arnr-maxframes", 1, "AltRef max frames (0..15)"),
+  .arnr_strength =
+      ARG_DEF(NULL, "arnr-strength", 1, "AltRef filter strength (0..6)"),
+  .tune_metric = ARG_DEF_ENUM(NULL, "tune", 1, "Distortion metric tuned with",
+                              tuning_enum),
+  .cq_level =
+      ARG_DEF(NULL, "cq-level", 1, "Constant/Constrained Quality level"),
+  .max_intra_rate_pct =
+      ARG_DEF(NULL, "max-intra-rate", 1, "Max I-frame bitrate (pct)"),
+#if CONFIG_AV1_ENCODER
+  .cpu_used_av1 =
+      ARG_DEF(NULL, "cpu-used", 1,
+              "Speed setting (0..6 in good mode, 6..9 in realtime mode)"),
+  .rowmtarg =
+      ARG_DEF(NULL, "row-mt", 1,
+              "Enable row based multi-threading (0: off, 1: on (default))"),
+  .tile_cols =
+      ARG_DEF(NULL, "tile-columns", 1, "Number of tile columns to use, log2"),
+  .tile_rows =
+      ARG_DEF(NULL, "tile-rows", 1, "Number of tile rows to use, log2"),
+  .enable_tpl_model = ARG_DEF(NULL, "enable-tpl-model", 1,
+                              "RDO based on frame temporal dependency "
+                              "(0: off, 1: backward source based). "
+                              "This is required for deltaq mode."),
+  .enable_keyframe_filtering = ARG_DEF(
+      NULL, "enable-keyframe-filtering", 1,
+      "Apply temporal filtering on key frame"
+      "(0: no filter, 1: filter without overlay (default), "
+      "2: filter with overlay - experimental, may break random access in "
+      "players.)"),
+  .tile_width = ARG_DEF(NULL, "tile-width", 1, "Tile widths (comma separated)"),
+  .tile_height =
+      ARG_DEF(NULL, "tile-height", 1, "Tile heights (command separated)"),
+  .lossless = ARG_DEF(NULL, "lossless", 1,
+                      "Lossless mode (0: false (default), 1: true)"),
+  .enable_cdef = ARG_DEF(
+      NULL, "enable-cdef", 1,
+      "Enable the constrained directional enhancement filter (0: false, "
+      "1: true (default))"),
+  .enable_restoration = ARG_DEF(NULL, "enable-restoration", 1,
+                                "Enable the loop restoration filter (0: false "
+                                "(default in Realtime mode), "
+                                "1: true (default in Non-realtime mode))"),
+  .enable_rect_partitions = ARG_DEF(NULL, "enable-rect-partitions", 1,
+                                    "Enable rectangular partitions "
+                                    "(0: false, 1: true (default))"),
+  .enable_ab_partitions =
+      ARG_DEF(NULL, "enable-ab-partitions", 1,
+              "Enable ab partitions (0: false, 1: true (default))"),
+  .enable_1to4_partitions = ARG_DEF(NULL, "enable-1to4-partitions", 1,
+                                    "Enable 1:4 and 4:1 partitions "
+                                    "(0: false, 1: true (default))"),
+  .min_partition_size =
+      ARG_DEF(NULL, "min-partition-size", 1,
+              "Set min partition size "
+              "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128). "
+              "On frame with 4k+ resolutions or higher speed settings, the min "
+              "partition size will have a minimum of 8."),
+  .max_partition_size =
+      ARG_DEF(NULL, "max-partition-size", 1,
+              "Set max partition size "
+              "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128)"),
+  .enable_dual_filter = ARG_DEF(NULL, "enable-dual-filter", 1,
+                                "Enable dual filter "
+                                "(0: false, 1: true (default))"),
+  .enable_chroma_deltaq = ARG_DEF(NULL, "enable-chroma-deltaq", 1,
+                                  "Enable chroma delta quant "
+                                  "(0: false (default), 1: true)"),
+  .enable_intra_edge_filter = ARG_DEF(NULL, "enable-intra-edge-filter", 1,
+                                      "Enable intra edge filtering "
+                                      "(0: false, 1: true (default))"),
+  .enable_order_hint = ARG_DEF(NULL, "enable-order-hint", 1,
+                               "Enable order hint "
+                               "(0: false, 1: true (default))"),
+  .enable_tx64 =
+      ARG_DEF(NULL, "enable-tx64", 1,
+              "Enable 64-pt transform (0: false, 1: true (default))"),
+  .enable_flip_idtx =
+      ARG_DEF(NULL, "enable-flip-idtx", 1,
+              "Enable extended transform type (0: false, 1: true (default)) "
+              "including FLIPADST_DCT, DCT_FLIPADST, FLIPADST_FLIPADST, "
+              "ADST_FLIPADST, FLIPADST_ADST, IDTX, V_DCT, H_DCT, V_ADST, "
+              "H_ADST, V_FLIPADST, H_FLIPADST"),
+  .enable_rect_tx =
+      ARG_DEF(NULL, "enable-rect-tx", 1,
+              "Enable rectangular transform (0: false, 1: true (default))"),
+  .enable_dist_wtd_comp = ARG_DEF(NULL, "enable-dist-wtd-comp", 1,
+                                  "Enable distance-weighted compound "
+                                  "(0: false, 1: true (default))"),
+  .enable_masked_comp = ARG_DEF(NULL, "enable-masked-comp", 1,
+                                "Enable masked (wedge/diff-wtd) compound "
+                                "(0: false, 1: true (default))"),
+  .enable_onesided_comp = ARG_DEF(NULL, "enable-onesided-comp", 1,
+                                  "Enable one sided compound "
+                                  "(0: false, 1: true (default))"),
+  .enable_interintra_comp = ARG_DEF(NULL, "enable-interintra-comp", 1,
+                                    "Enable interintra compound "
+                                    "(0: false, 1: true (default))"),
+  .enable_smooth_interintra = ARG_DEF(NULL, "enable-smooth-interintra", 1,
+                                      "Enable smooth interintra mode "
+                                      "(0: false, 1: true (default))"),
+  .enable_diff_wtd_comp = ARG_DEF(NULL, "enable-diff-wtd-comp", 1,
+                                  "Enable difference-weighted compound "
+                                  "(0: false, 1: true (default))"),
+  .enable_interinter_wedge = ARG_DEF(NULL, "enable-interinter-wedge", 1,
+                                     "Enable interinter wedge compound "
+                                     "(0: false, 1: true (default))"),
+  .enable_interintra_wedge = ARG_DEF(NULL, "enable-interintra-wedge", 1,
+                                     "Enable interintra wedge compound "
+                                     "(0: false, 1: true (default))"),
+  .enable_global_motion = ARG_DEF(NULL, "enable-global-motion", 1,
+                                  "Enable global motion "
+                                  "(0: false, 1: true (default))"),
+  .enable_warped_motion = ARG_DEF(NULL, "enable-warped-motion", 1,
+                                  "Enable local warped motion "
+                                  "(0: false, 1: true (default))"),
+  .enable_filter_intra = ARG_DEF(NULL, "enable-filter-intra", 1,
+                                 "Enable filter intra prediction mode "
+                                 "(0: false, 1: true (default))"),
+  .enable_smooth_intra = ARG_DEF(NULL, "enable-smooth-intra", 1,
+                                 "Enable smooth intra prediction modes "
+                                 "(0: false, 1: true (default))"),
+  .enable_paeth_intra = ARG_DEF(
+      NULL, "enable-paeth-intra", 1,
+      "Enable Paeth intra prediction mode (0: false, 1: true (default))"),
+  .enable_cfl_intra = ARG_DEF(NULL, "enable-cfl-intra", 1,
+                              "Enable chroma from luma intra prediction mode "
+                              "(0: false, 1: true (default))"),
+  .force_video_mode = ARG_DEF(NULL, "force-video-mode", 1,
+                              "Force video mode (0: false, 1: true (default))"),
+  .enable_obmc = ARG_DEF(NULL, "enable-obmc", 1,
+                         "Enable OBMC (0: false, 1: true (default))"),
+  .enable_overlay =
+      ARG_DEF(NULL, "enable-overlay", 1,
+              "Enable coding overlay frames (0: false, 1: true (default))"),
+  .enable_palette =
+      ARG_DEF(NULL, "enable-palette", 1,
+              "Enable palette prediction mode (0: false, 1: true (default))"),
+  .enable_intrabc = ARG_DEF(NULL, "enable-intrabc", 1,
+                            "Enable intra block copy prediction mode "
+                            "(0: false, 1: true (default))"),
+  .enable_angle_delta =
+      ARG_DEF(NULL, "enable-angle-delta", 1,
+              "Enable intra angle delta (0: false, 1: true (default))"),
+  .disable_trellis_quant = ARG_DEF(
+      NULL, "disable-trellis-quant", 1,
+      "Disable trellis optimization of quantized coefficients (0: false "
+      "1: true  2: true for rd search 3: true for estimate yrd serch "
+      "(default))"),
+  .enable_qm =
+      ARG_DEF(NULL, "enable-qm", 1,
+              "Enable quantisation matrices (0: false (default), 1: true)"),
+  .qm_min = ARG_DEF(NULL, "qm-min", 1,
+                    "Min quant matrix flatness (0..15), default is 8"),
+  .qm_max = ARG_DEF(NULL, "qm-max", 1,
+                    "Max quant matrix flatness (0..15), default is 15"),
+  .reduced_tx_type_set = ARG_DEF(NULL, "reduced-tx-type-set", 1,
+                                 "Use reduced set of transform types"),
+  .use_intra_dct_only =
+      ARG_DEF(NULL, "use-intra-dct-only", 1, "Use DCT only for INTRA modes"),
+  .use_inter_dct_only =
+      ARG_DEF(NULL, "use-inter-dct-only", 1, "Use DCT only for INTER modes"),
+  .use_intra_default_tx_only =
+      ARG_DEF(NULL, "use-intra-default-tx-only", 1,
+              "Use Default-transform only for INTRA modes"),
+  .quant_b_adapt = ARG_DEF(NULL, "quant-b-adapt", 1, "Use adaptive quantize_b"),
+  .coeff_cost_upd_freq = ARG_DEF(NULL, "coeff-cost-upd-freq", 1,
+                                 "Update freq for coeff costs"
+                                 "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off"),
+  .mode_cost_upd_freq = ARG_DEF(NULL, "mode-cost-upd-freq", 1,
+                                "Update freq for mode costs"
+                                "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off"),
+  .mv_cost_upd_freq = ARG_DEF(NULL, "mv-cost-upd-freq", 1,
+                              "Update freq for mv costs"
+                              "0: SB, 1: SB Row per Tile, 2: Tile, 3: Off"),
+  .num_tg = ARG_DEF(NULL, "num-tile-groups", 1,
+                    "Maximum number of tile groups, default is 1"),
+  .mtu_size =
+      ARG_DEF(NULL, "mtu-size", 1,
+              "MTU size for a tile group, default is 0 (no MTU targeting), "
+              "overrides maximum number of tile groups"),
+  .timing_info = ARG_DEF_ENUM(
+      NULL, "timing-info", 1,
+      "Signal timing info in the bitstream (model unly works for no "
+      "hidden frames, no super-res yet):",
+      timing_info_enum),
+#if CONFIG_TUNE_VMAF
+  .vmaf_model_path =
+      ARG_DEF(NULL, "vmaf-model-path", 1, "Path to the VMAF model file"),
+#endif
+  .film_grain_test = ARG_DEF(
+      NULL, "film-grain-test", 1,
+      "Film grain test vectors (0: none (default), 1: test-1  2: test-2, "
+      "... 16: test-16)"),
+  .film_grain_table = ARG_DEF(NULL, "film-grain-table", 1,
+                              "Path to file containing film grain parameters"),
+#if CONFIG_DENOISE
+  .denoise_noise_level =
+      ARG_DEF(NULL, "denoise-noise-level", 1,
+              "Amount of noise (from 0 = don't denoise, to 50)"),
+  .denoise_block_size = ARG_DEF(NULL, "denoise-block-size", 1,
+                                "Denoise block size (default = 32)"),
+#endif
+  .enable_ref_frame_mvs =
+      ARG_DEF(NULL, "enable-ref-frame-mvs", 1,
+              "Enable temporal mv prediction (default is 1)"),
+  .frame_parallel_decoding =
+      ARG_DEF(NULL, "frame-parallel", 1,
+              "Enable frame parallel decodability features "
+              "(0: false (default), 1: true)"),
+  .error_resilient_mode = ARG_DEF(NULL, "error-resilient", 1,
+                                  "Enable error resilient features "
+                                  "(0: false (default), 1: true)"),
+  .aq_mode = ARG_DEF(NULL, "aq-mode", 1,
+                     "Adaptive quantization mode (0: off (default), 1: "
+                     "variance 2: complexity, "
+                     "3: cyclic refresh)"),
+  .deltaq_mode =
+      ARG_DEF(NULL, "deltaq-mode", 1,
+              "Delta qindex mode (0: off, 1: deltaq objective (default), "
+              "2: deltaq perceptual). "
+              "Currently this requires enable-tpl-model as a prerequisite."),
+  .deltalf_mode = ARG_DEF(NULL, "delta-lf-mode", 1,
+                          "Enable delta-lf-mode (0: off (default), 1: on)"),
+  .frame_periodic_boost =
+      ARG_DEF(NULL, "frame-boost", 1,
+              "Enable frame periodic boost (0: off (default), 1: on)"),
+  .gf_cbr_boost_pct = ARG_DEF(NULL, "gf-cbr-boost", 1,
+                              "Boost for Golden Frame in CBR mode (pct)"),
+  .max_inter_rate_pct =
+      ARG_DEF(NULL, "max-inter-rate", 1, "Max P-frame bitrate (pct)"),
+  .min_gf_interval = ARG_DEF(
+      NULL, "min-gf-interval", 1,
+      "min gf/arf frame interval (default 0, indicating in-built behavior)"),
+  .max_gf_interval = ARG_DEF(
+      NULL, "max-gf-interval", 1,
+      "max gf/arf frame interval (default 0, indicating in-built behavior)"),
+  .gf_min_pyr_height =
+      ARG_DEF(NULL, "gf-min-pyr-height", 1,
+              "Min height for GF group pyramid structure (0 (default) to 5)"),
+  .gf_max_pyr_height = ARG_DEF(
+      NULL, "gf-max-pyr-height", 1,
+      "maximum height for GF group pyramid structure (0 to 5 (default))"),
+  .max_reference_frames = ARG_DEF(NULL, "max-reference-frames", 1,
+                                  "maximum number of reference frames allowed "
+                                  "per frame (3 to 7 (default))"),
+  .reduced_reference_set =
+      ARG_DEF(NULL, "reduced-reference-set", 1,
+              "Use reduced set of single and compound references (0: off "
+              "(default), 1: on)"),
+  .target_seq_level_idx = ARG_DEF(
+      NULL, "target-seq-level-idx", 1,
+      "Target sequence level index. "
+      "Possible values are in the form of \"ABxy\"(pad leading zeros if "
+      "less than 4 digits). "
+      "AB: Operating point(OP) index, "
+      "xy: Target level index for the OP. "
+      "E.g. \"0\" means target level index 0 for the 0th OP, "
+      "\"1021\" means target level index 21 for the 10th OP."),
+  .set_min_cr = ARG_DEF(
+      NULL, "min-cr", 1,
+      "Set minimum compression ratio. Take integer values. Default is 0. "
+      "If non-zero, encoder will try to keep the compression ratio of "
+      "each frame to be higher than the given value divided by 100."),
+
+  .input_color_primaries = ARG_DEF_ENUM(
+      NULL, "color-primaries", 1,
+      "Color primaries (CICP) of input content:", color_primaries_enum),
+
+  .input_transfer_characteristics =
+      ARG_DEF_ENUM(NULL, "transfer-characteristics", 1,
+                   "Transfer characteristics (CICP) of input content:",
+                   transfer_characteristics_enum),
+
+  .input_matrix_coefficients = ARG_DEF_ENUM(
+      NULL, "matrix-coefficients", 1,
+      "Matrix coefficients (CICP) of input content:", matrix_coefficients_enum),
+
+  .input_chroma_sample_position =
+      ARG_DEF_ENUM(NULL, "chroma-sample-position", 1,
+                   "The chroma sample position when chroma 4:2:0 is signaled:",
+                   chroma_sample_position_enum),
+
+  .tune_content = ARG_DEF_ENUM(NULL, "tune-content", 1, "Tune content type",
+                               tune_content_enum),
+
+  .cdf_update_mode =
+      ARG_DEF(NULL, "cdf-update-mode", 1,
+              "CDF update mode for entropy coding "
+              "(0: no CDF update, 1: update CDF on all frames(default), "
+              "2: selectively update CDF on some frames"),
+
+  .superblock_size = ARG_DEF_ENUM(NULL, "sb-size", 1, "Superblock size to use",
+                                  superblock_size_enum),
+
+  .set_tier_mask =
+      ARG_DEF(NULL, "set-tier-mask", 1,
+              "Set bit mask to specify which tier each of the 32 possible "
+              "operating points conforms to. "
+              "Bit value 0(defualt): Main Tier, 1: High Tier."),
+
+  .use_fixed_qp_offsets =
+      ARG_DEF(NULL, "use-fixed-qp-offsets", 1,
+              "Enable fixed QP offsets for frames at different levels of the "
+              "pyramid. Selected automatically from --cq-level if "
+              "--fixed-qp-offsets is not provided. If this option is not "
+              "specified (default), offsets are adaptively chosen by the "
+              "encoder."),
+
+  .fixed_qp_offsets = ARG_DEF(
+      NULL, "fixed-qp-offsets", 1,
+      "Set fixed QP offsets for frames at different levels of the "
+      "pyramid. Comma-separated list of 5 offsets for keyframe, ALTREF, "
+      "and 3 levels of internal alt-refs. If this option is not "
+      "specified (default), offsets are adaptively chosen by the "
+      "encoder."),
+
+  .vbr_corpus_complexity_lap = ARG_DEF(
+      NULL, "vbr-corpus-complexity-lap", 1,
+      "Set average corpus complexity per mb for single pass VBR using lap. "
+      "(0..10000), default is 0")
+#endif  // CONFIG_AV1_ENCODER
+};
diff --git a/av1/arg_defs.h b/av1/arg_defs.h
new file mode 100644
index 0000000..ac0d636
--- /dev/null
+++ b/av1/arg_defs.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2021, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+#ifndef AOM_AV1_ARG_DEFS_H_
+#define AOM_AV1_ARG_DEFS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "config/aom_config.h"
+#include "common/args_helper.h"
+#if CONFIG_WEBM_IO
+#include "common/webmenc.h"
+#endif
+#include "aom/aomcx.h"
+
+enum TestDecodeFatality {
+  TEST_DECODE_OFF,
+  TEST_DECODE_FATAL,
+  TEST_DECODE_WARN,
+};
+
+typedef struct av1_codec_arg_definitions {
+  arg_def_t help;
+  arg_def_t debugmode;
+  arg_def_t outputfile;
+  arg_def_t use_yv12;
+  arg_def_t use_i420;
+  arg_def_t use_i422;
+  arg_def_t use_i444;
+  arg_def_t codecarg;
+  arg_def_t passes;
+  arg_def_t pass_arg;
+  arg_def_t fpf_name;
+  arg_def_t limit;
+  arg_def_t skip;
+  arg_def_t good_dl;
+  arg_def_t rt_dl;
+  arg_def_t quietarg;
+  arg_def_t verbosearg;
+  arg_def_t psnrarg;
+  arg_def_t use_cfg;
+  arg_def_t recontest;
+  arg_def_t framerate;
+  arg_def_t use_webm;
+  arg_def_t use_ivf;
+  arg_def_t use_obu;
+  arg_def_t q_hist_n;
+  arg_def_t rate_hist_n;
+  arg_def_t disable_warnings;
+  arg_def_t disable_warning_prompt;
+  arg_def_t bitdeptharg;
+  arg_def_t inbitdeptharg;
+  arg_def_t input_chroma_subsampling_x;
+  arg_def_t input_chroma_subsampling_y;
+  arg_def_t usage;
+  arg_def_t threads;
+  arg_def_t profile;
+  arg_def_t width;
+  arg_def_t height;
+  arg_def_t forced_max_frame_width;
+  arg_def_t forced_max_frame_height;
+#if CONFIG_WEBM_IO
+  arg_def_t stereo_mode;
+#endif
+  arg_def_t timebase;
+  arg_def_t global_error_resilient;
+  arg_def_t lag_in_frames;
+  arg_def_t large_scale_tile;
+  arg_def_t monochrome;
+  arg_def_t full_still_picture_hdr;
+  arg_def_t use_16bit_internal;
+  arg_def_t dropframe_thresh;
+  arg_def_t resize_mode;
+  arg_def_t resize_denominator;
+  arg_def_t resize_kf_denominator;
+  arg_def_t superres_mode;
+  arg_def_t superres_denominator;
+  arg_def_t superres_kf_denominator;
+  arg_def_t superres_qthresh;
+  arg_def_t superres_kf_qthresh;
+  arg_def_t end_usage;
+  arg_def_t target_bitrate;
+  arg_def_t min_quantizer;
+  arg_def_t max_quantizer;
+  arg_def_t undershoot_pct;
+  arg_def_t overshoot_pct;
+  arg_def_t buf_sz;
+  arg_def_t buf_initial_sz;
+  arg_def_t buf_optimal_sz;
+  arg_def_t bias_pct;
+  arg_def_t minsection_pct;
+  arg_def_t maxsection_pct;
+  arg_def_t fwd_kf_enabled;
+  arg_def_t kf_min_dist;
+  arg_def_t kf_max_dist;
+  arg_def_t kf_disabled;
+  arg_def_t sframe_dist;
+  arg_def_t sframe_mode;
+  arg_def_t save_as_annexb;
+  arg_def_t noise_sens;
+  arg_def_t sharpness;
+  arg_def_t static_thresh;
+  arg_def_t auto_altref;
+  arg_def_t arnr_maxframes;
+  arg_def_t arnr_strength;
+  arg_def_t tune_metric;
+  arg_def_t cq_level;
+  arg_def_t max_intra_rate_pct;
+#if CONFIG_AV1_ENCODER
+  arg_def_t cpu_used_av1;
+  arg_def_t rowmtarg;
+  arg_def_t tile_cols;
+  arg_def_t tile_rows;
+  arg_def_t enable_tpl_model;
+  arg_def_t enable_keyframe_filtering;
+  arg_def_t tile_width;
+  arg_def_t tile_height;
+  arg_def_t lossless;
+  arg_def_t enable_cdef;
+  arg_def_t enable_restoration;
+  arg_def_t enable_rect_partitions;
+  arg_def_t enable_ab_partitions;
+  arg_def_t enable_1to4_partitions;
+  arg_def_t min_partition_size;
+  arg_def_t max_partition_size;
+  arg_def_t enable_dual_filter;
+  arg_def_t enable_chroma_deltaq;
+  arg_def_t enable_intra_edge_filter;
+  arg_def_t enable_order_hint;
+  arg_def_t enable_tx64;
+  arg_def_t enable_flip_idtx;
+  arg_def_t enable_rect_tx;
+  arg_def_t enable_dist_wtd_comp;
+  arg_def_t enable_masked_comp;
+  arg_def_t enable_onesided_comp;
+  arg_def_t enable_interintra_comp;
+  arg_def_t enable_smooth_interintra;
+  arg_def_t enable_diff_wtd_comp;
+  arg_def_t enable_interinter_wedge;
+  arg_def_t enable_interintra_wedge;
+  arg_def_t enable_global_motion;
+  arg_def_t enable_warped_motion;
+  arg_def_t enable_filter_intra;
+  arg_def_t enable_smooth_intra;
+  arg_def_t enable_paeth_intra;
+  arg_def_t enable_cfl_intra;
+  arg_def_t force_video_mode;
+  arg_def_t enable_obmc;
+  arg_def_t enable_overlay;
+  arg_def_t enable_palette;
+  arg_def_t enable_intrabc;
+  arg_def_t enable_angle_delta;
+  arg_def_t disable_trellis_quant;
+  arg_def_t enable_qm;
+  arg_def_t qm_min;
+  arg_def_t qm_max;
+  arg_def_t reduced_tx_type_set;
+  arg_def_t use_intra_dct_only;
+  arg_def_t use_inter_dct_only;
+  arg_def_t use_intra_default_tx_only;
+  arg_def_t quant_b_adapt;
+  arg_def_t coeff_cost_upd_freq;
+  arg_def_t mode_cost_upd_freq;
+  arg_def_t mv_cost_upd_freq;
+  arg_def_t num_tg;
+  arg_def_t mtu_size;
+  arg_def_t timing_info;
+#if CONFIG_TUNE_VMAF
+  arg_def_t vmaf_model_path;
+#endif
+  arg_def_t film_grain_test;
+  arg_def_t film_grain_table;
+#if CONFIG_DENOISE
+  arg_def_t denoise_noise_level;
+  arg_def_t denoise_block_size;
+#endif
+  arg_def_t enable_ref_frame_mvs;
+  arg_def_t frame_parallel_decoding;
+  arg_def_t error_resilient_mode;
+  arg_def_t aq_mode;
+  arg_def_t deltaq_mode;
+  arg_def_t deltalf_mode;
+  arg_def_t frame_periodic_boost;
+  arg_def_t gf_cbr_boost_pct;
+  arg_def_t max_inter_rate_pct;
+  arg_def_t min_gf_interval;
+  arg_def_t max_gf_interval;
+  arg_def_t gf_min_pyr_height;
+  arg_def_t gf_max_pyr_height;
+  arg_def_t max_reference_frames;
+  arg_def_t reduced_reference_set;
+  arg_def_t target_seq_level_idx;
+  arg_def_t set_min_cr;
+  arg_def_t input_color_primaries;
+  arg_def_t input_transfer_characteristics;
+  arg_def_t input_matrix_coefficients;
+  arg_def_t input_chroma_sample_position;
+  arg_def_t tune_content;
+  arg_def_t cdf_update_mode;
+  arg_def_t superblock_size;
+  arg_def_t set_tier_mask;
+  arg_def_t use_fixed_qp_offsets;
+  arg_def_t fixed_qp_offsets;
+  arg_def_t vbr_corpus_complexity_lap;
+#endif  // CONFIG_AV1_ENCODER
+} av1_codec_arg_definitions_t;
+
+extern const av1_codec_arg_definitions_t g_av1_codec_arg_defs;
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // AOM_AV1_ARG_DEFS_H_
diff --git a/av1/av1.cmake b/av1/av1.cmake
index 0fafad3..718254b 100644
--- a/av1/av1.cmake
+++ b/av1/av1.cmake
@@ -14,6 +14,10 @@
 set(AOM_AV1_AV1_CMAKE_ 1)
 
 list(APPEND AOM_AV1_COMMON_SOURCES
+            "${AOM_ROOT}/common/args_helper.h"
+            "${AOM_ROOT}/common/args_helper.c"
+            "${AOM_ROOT}/av1/arg_defs.h"
+            "${AOM_ROOT}/av1/arg_defs.c"
             "${AOM_ROOT}/av1/av1_iface_common.h"
             "${AOM_ROOT}/av1/common/alloccommon.c"
             "${AOM_ROOT}/av1/common/alloccommon.h"
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index 02afee5..3ea3b8f 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "aom_mem/aom_mem.h"
 #include "config/aom_config.h"
 #include "config/aom_version.h"
 
@@ -26,6 +27,9 @@
 #include "av1/encoder/encoder.h"
 #include "av1/encoder/ethread.h"
 #include "av1/encoder/firstpass.h"
+#include "av1/arg_defs.h"
+
+#include "common/args_helper.h"
 
 #define MAG_SIZE (4)
 
@@ -2766,6 +2770,360 @@
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
+static aom_codec_err_t encoder_set_option(aom_codec_alg_priv_t *ctx,
+                                          const char *name, const char *value) {
+  if (ctx == NULL || name == NULL || value == NULL)
+    return AOM_CODEC_INVALID_PARAM;
+  struct av1_extracfg extra_cfg = ctx->extra_cfg;
+  // Used to mock the argv with just one string "--{name}={value}"
+  char *argv[2] = { NULL, "" };
+  size_t len = strlen(name) + strlen(value) + 4;
+  char *err_string = ctx->cpi->common.error.detail;
+
+#if __STDC_VERSION__ >= 201112L
+  static_assert(sizeof(ctx->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN,
+                "The size of the err_msg buffer for arg_match_helper must be "
+                "at least ARG_ERR_MSG_MAX_LEN");
+#else
+  assert(sizeof(ctx->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN);
+#endif
+
+  argv[0] = aom_malloc(len * sizeof(argv[1][0]));
+  snprintf(argv[0], len, "--%s=%s", name, value);
+  struct arg arg;
+
+  int match = 1;
+  if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_keyframe_filtering,
+                       argv, err_string)) {
+    extra_cfg.enable_keyframe_filtering =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.min_gf_interval, argv,
+                              err_string)) {
+    extra_cfg.min_gf_interval = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.max_gf_interval, argv,
+                              err_string)) {
+    extra_cfg.max_gf_interval = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.gf_min_pyr_height,
+                              argv, err_string)) {
+    extra_cfg.gf_min_pyr_height = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.gf_max_pyr_height,
+                              argv, err_string)) {
+    extra_cfg.gf_max_pyr_height = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.cpu_used_av1, argv,
+                              err_string)) {
+    extra_cfg.cpu_used = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.auto_altref, argv,
+                              err_string)) {
+    extra_cfg.enable_auto_alt_ref = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.noise_sens, argv,
+                              err_string)) {
+    extra_cfg.noise_sensitivity = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.sharpness, argv,
+                              err_string)) {
+    extra_cfg.sharpness = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.static_thresh, argv,
+                              err_string)) {
+    extra_cfg.static_thresh = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.rowmtarg, argv,
+                              err_string)) {
+    extra_cfg.row_mt = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.tile_cols, argv,
+                              err_string)) {
+    extra_cfg.tile_columns = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.tile_rows, argv,
+                              err_string)) {
+    extra_cfg.tile_rows = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_tpl_model,
+                              argv, err_string)) {
+    extra_cfg.enable_tpl_model = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.arnr_maxframes, argv,
+                              err_string)) {
+    extra_cfg.arnr_max_frames = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.arnr_strength, argv,
+                              err_string)) {
+    extra_cfg.arnr_strength = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.tune_metric, argv,
+                              err_string)) {
+    extra_cfg.tuning = arg_parse_enum_helper(&arg, err_string);
+  }
+#if CONFIG_TUNE_VMAF
+  else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.vmaf_model_path, argv,
+                            err_string)) {
+    extra_cfg.vmaf_model_path = value;
+  }
+#endif
+  else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.cq_level, argv,
+                            err_string)) {
+    extra_cfg.cq_level = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.max_intra_rate_pct,
+                              argv, err_string)) {
+    extra_cfg.rc_max_intra_bitrate_pct =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.max_inter_rate_pct,
+                              argv, err_string)) {
+    extra_cfg.rc_max_inter_bitrate_pct =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.gf_cbr_boost_pct,
+                              argv, err_string)) {
+    extra_cfg.gf_cbr_boost_pct = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.lossless, argv,
+                              err_string)) {
+    extra_cfg.lossless = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_cdef, argv,
+                              err_string)) {
+    extra_cfg.enable_cdef = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_restoration,
+                              argv, err_string)) {
+    extra_cfg.enable_restoration = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.force_video_mode,
+                              argv, err_string)) {
+    extra_cfg.force_video_mode = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_obmc, argv,
+                              err_string)) {
+    extra_cfg.enable_obmc = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.disable_trellis_quant,
+                              argv, err_string)) {
+    extra_cfg.disable_trellis_quant = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_qm, argv,
+                              err_string)) {
+    extra_cfg.enable_qm = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.qm_max, argv,
+                              err_string)) {
+    extra_cfg.qm_max = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.qm_min, argv,
+                              err_string)) {
+    extra_cfg.qm_min = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.num_tg, argv,
+                              err_string)) {
+    extra_cfg.num_tg = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.mtu_size, argv,
+                              err_string)) {
+    extra_cfg.mtu_size = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.timing_info, argv,
+                              err_string)) {
+    extra_cfg.timing_info_type = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.frame_parallel_decoding,
+                              argv, err_string)) {
+    extra_cfg.frame_parallel_decoding_mode =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_dual_filter,
+                              argv, err_string)) {
+    extra_cfg.enable_dual_filter = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_chroma_deltaq,
+                              argv, err_string)) {
+    extra_cfg.enable_chroma_deltaq = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.aq_mode, argv,
+                              err_string)) {
+    extra_cfg.aq_mode = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.deltaq_mode, argv,
+                              err_string)) {
+    extra_cfg.deltaq_mode = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.deltalf_mode, argv,
+                              err_string)) {
+    extra_cfg.deltalf_mode = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.frame_periodic_boost,
+                              argv, err_string)) {
+    extra_cfg.frame_periodic_boost = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.tune_content, argv,
+                              err_string)) {
+    extra_cfg.content = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.input_color_primaries,
+                              argv, err_string)) {
+    extra_cfg.color_primaries = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(
+                 &arg, &g_av1_codec_arg_defs.input_transfer_characteristics,
+                 argv, err_string)) {
+    extra_cfg.transfer_characteristics =
+        arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.input_matrix_coefficients,
+                              argv, err_string)) {
+    extra_cfg.matrix_coefficients = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(
+                 &arg, &g_av1_codec_arg_defs.input_chroma_sample_position, argv,
+                 err_string)) {
+    extra_cfg.chroma_sample_position = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.superblock_size, argv,
+                              err_string)) {
+    extra_cfg.superblock_size = arg_parse_enum_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.error_resilient_mode,
+                              argv, err_string)) {
+    extra_cfg.error_resilient_mode = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.sframe_mode, argv,
+                              err_string)) {
+    extra_cfg.s_frame_mode = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.film_grain_test, argv,
+                              err_string)) {
+    extra_cfg.film_grain_test_vector = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.film_grain_table,
+                              argv, err_string)) {
+    extra_cfg.film_grain_table_filename = value;
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.cdf_update_mode, argv,
+                              err_string)) {
+    extra_cfg.cdf_update_mode = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_rect_partitions,
+                              argv, err_string)) {
+    extra_cfg.enable_rect_partitions = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_ab_partitions,
+                              argv, err_string)) {
+    extra_cfg.enable_ab_partitions = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_1to4_partitions,
+                              argv, err_string)) {
+    extra_cfg.enable_1to4_partitions = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.min_partition_size,
+                              argv, err_string)) {
+    extra_cfg.min_partition_size = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.max_partition_size,
+                              argv, err_string)) {
+    extra_cfg.max_partition_size = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_intra_edge_filter,
+                              argv, err_string)) {
+    extra_cfg.enable_intra_edge_filter =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_order_hint,
+                              argv, err_string)) {
+    extra_cfg.enable_order_hint = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_tx64, argv,
+                              err_string)) {
+    extra_cfg.enable_tx64 = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_flip_idtx,
+                              argv, err_string)) {
+    extra_cfg.enable_flip_idtx = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_rect_tx, argv,
+                              err_string)) {
+    extra_cfg.enable_rect_tx = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_dist_wtd_comp,
+                              argv, err_string)) {
+    extra_cfg.enable_dist_wtd_comp = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.max_reference_frames,
+                              argv, err_string)) {
+    extra_cfg.max_reference_frames = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.reduced_reference_set,
+                              argv, err_string)) {
+    extra_cfg.enable_reduced_reference_set =
+        arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_ref_frame_mvs,
+                              argv, err_string)) {
+    extra_cfg.enable_ref_frame_mvs = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_masked_comp,
+                              argv, err_string)) {
+    extra_cfg.enable_masked_comp = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_onesided_comp,
+                              argv, err_string)) {
+    extra_cfg.enable_onesided_comp = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_interintra_comp,
+                              argv, err_string)) {
+    extra_cfg.enable_interintra_comp = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_smooth_interintra,
+                              argv, err_string)) {
+    extra_cfg.enable_smooth_interintra = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_diff_wtd_comp,
+                              argv, err_string)) {
+    extra_cfg.enable_diff_wtd_comp = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_interinter_wedge,
+                              argv, err_string)) {
+    extra_cfg.enable_interinter_wedge = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.enable_interintra_wedge,
+                              argv, err_string)) {
+    extra_cfg.enable_interintra_wedge = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_global_motion,
+                              argv, err_string)) {
+    extra_cfg.enable_global_motion = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_warped_motion,
+                              argv, err_string)) {
+    extra_cfg.enable_warped_motion = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_filter_intra,
+                              argv, err_string)) {
+    extra_cfg.enable_filter_intra = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_smooth_intra,
+                              argv, err_string)) {
+    extra_cfg.enable_smooth_intra = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_paeth_intra,
+                              argv, err_string)) {
+    extra_cfg.enable_paeth_intra = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_cfl_intra,
+                              argv, err_string)) {
+    extra_cfg.enable_cfl_intra = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.superres_mode, argv,
+                              err_string)) {
+    extra_cfg.enable_superres = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_overlay, argv,
+                              err_string)) {
+    extra_cfg.enable_overlay = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_palette, argv,
+                              err_string)) {
+    extra_cfg.enable_palette = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_intrabc, argv,
+                              err_string)) {
+    extra_cfg.enable_intrabc = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_angle_delta,
+                              argv, err_string)) {
+    extra_cfg.enable_angle_delta = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.reduced_tx_type_set,
+                              argv, err_string)) {
+    extra_cfg.reduced_tx_type_set = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.use_intra_dct_only,
+                              argv, err_string)) {
+    extra_cfg.use_intra_dct_only = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.use_inter_dct_only,
+                              argv, err_string)) {
+    extra_cfg.use_inter_dct_only = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.use_intra_default_tx_only,
+                              argv, err_string)) {
+    extra_cfg.use_intra_default_tx_only =
+        arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.quant_b_adapt, argv,
+                              err_string)) {
+    extra_cfg.quant_b_adapt = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.vbr_corpus_complexity_lap,
+                              argv, err_string)) {
+    extra_cfg.vbr_corpus_complexity_lap =
+        arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.set_tier_mask, argv,
+                              err_string)) {
+    extra_cfg.tier_mask = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.set_min_cr, argv,
+                              err_string)) {
+    extra_cfg.min_cr = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.coeff_cost_upd_freq,
+                              argv, err_string)) {
+    extra_cfg.coeff_cost_upd_freq = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.mode_cost_upd_freq,
+                              argv, err_string)) {
+    extra_cfg.mode_cost_upd_freq = arg_parse_uint_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.mv_cost_upd_freq,
+                              argv, err_string)) {
+    extra_cfg.mv_cost_upd_freq = arg_parse_uint_helper(&arg, err_string);
+  } else {
+    match = 0;
+    snprintf(err_string, ARG_ERR_MSG_MAX_LEN, "Cannot find aom option %s",
+             name);
+  }
+  aom_free(argv[0]);
+
+  if (strlen(err_string) != 0) {
+    ctx->base.err_detail = err_string;
+    return AOM_CODEC_INVALID_PARAM;
+  }
+
+  ctx->base.err_detail = NULL;
+
+  if (!match) {
+    return AOM_CODEC_INVALID_PARAM;
+  }
+  return update_extra_cfg(ctx, &extra_cfg);
+}
+
 static aom_codec_err_t ctrl_get_seq_level_idx(aom_codec_alg_priv_t *ctx,
                                               va_list args) {
   int *const arg = va_arg(args, int *);
@@ -3087,7 +3445,8 @@
       encoder_set_config,          // aom_codec_enc_config_set_fn_t
       encoder_get_global_headers,  // aom_codec_get_global_headers_fn_t
       encoder_get_preview          // aom_codec_get_preview_frame_fn_t
-  }
+  },
+  encoder_set_option  // aom_codec_set_option_fn_t
 };
 
 aom_codec_iface_t *aom_codec_av1_cx(void) { return &aom_codec_av1_cx_algo; }
diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c
index 21050cd..1ee8a57 100644
--- a/av1/av1_dx_iface.c
+++ b/av1/av1_dx_iface.c
@@ -1598,7 +1598,8 @@
       NULL,  // aom_codec_enc_config_set_fn_t
       NULL,  // aom_codec_get_global_headers_fn_t
       NULL   // aom_codec_get_preview_frame_fn_t
-  }
+  },
+  NULL  // aom_codec_set_option_fn_t
 };
 
 aom_codec_iface_t *aom_codec_av1_dx(void) { return &aom_codec_av1_dx_algo; }