Replace "VP8" with "AOM" Note: Check AOMD_SET_DESCRIPTOR; there was a VPX & VP8 version that when renamed become the same. Change-Id: I022a71c0dfcd77948dda35ec754167e03bca616d

diff --git a/CHANGELOG b/CHANGELOG
index 3f44f6c..ee174d4 100644
--- a/CHANGELOG
+++ b/CHANGELOG

@@ -3,14 +3,14 @@
   decoding processes.
 
   - Upgrading:
-    This release is ABI incompatible with 1.4.0. It drops deprecated VP8
+    This release is ABI incompatible with 1.4.0. It drops deprecated AOM
     controls and adds a variety of VP9 controls for testing.
 
     The aomenc utility now prefers VP9 by default.
 
   - Enhancements:
     Faster VP9 encoding and decoding
-    Smaller library size by combining functions used by VP8 and VP9
+    Smaller library size by combining functions used by AOM and VP9
 
   - Bug Fixes:
     A variety of fuzzing issues
@@ -40,8 +40,8 @@
 
 2013-11-15 v1.3.0 "Forest"
   This release introduces the VP9 codec in a backward-compatible way.
-  All existing users of VP8 can continue to use the library without
-  modification. However, some VP8 options do not map to VP9 in the same manner.
+  All existing users of AOM can continue to use the library without
+  modification. However, some AOM options do not map to VP9 in the same manner.
 
   The VP9 encoder in this release is not feature complete. Users interested in
   the encoder are advised to use the git master branch and discuss issues on
@@ -78,7 +78,7 @@
       Add encoding option --static-thresh
 
   - Speed:
-      Miscellaneous speed optimizations for VP8 and VP9.
+      Miscellaneous speed optimizations for AOM and VP9.
 
   - Quality:
       In general, quality is consistent with the Eider release.
@@ -99,7 +99,7 @@
     document for that release.
 
   - Enhancements:
-      VP8 optimizations for MIPS dspr2
+      AOM optimizations for MIPS dspr2
       aomenc: add -quiet option
 
   - Speed:
@@ -128,7 +128,7 @@
     document for that release.
 
     This release introduces a new temporal denoiser, controlled by the
-    VP8E_SET_NOISE_SENSITIVITY control. The temporal denoiser does not
+    AOME_SET_NOISE_SENSITIVITY control. The temporal denoiser does not
     currently take a strength parameter, so the control is effectively
     a boolean - zero (off) or non-zero (on). For compatibility with
     existing applications, the values accepted are the same as those
@@ -620,5 +620,5 @@
 
 
 2010-05-18 v0.9.0
-  - Initial open source release. Welcome to WebM and VP8!
+  - Initial open source release. Welcome to WebM and AOM!
 

diff --git a/aom/aom_encoder.h b/aom/aom_encoder.h
index 3f1101d..7da619f 100644
--- a/aom/aom_encoder.h
+++ b/aom/aom_encoder.h

@@ -798,7 +798,7 @@
  *
  * \param[in]    iface     Pointer to the algorithm interface to use.
  * \param[out]   cfg       Configuration buffer to populate.
- * \param[in]    reserved  Must set to 0 for VP8 and VP9.
+ * \param[in]    reserved  Must set to 0 for AOM and VP9.
  *
  * \retval #AOM_CODEC_OK
  *     The configuration was populated.

diff --git a/aom/vp8.h b/aom/vp8.h
index d8fef11..20c99e3 100644
--- a/aom/vp8.h
+++ b/aom/vp8.h

@@ -9,9 +9,9 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
-/*!\defgroup vp8 VP8
+/*!\defgroup vp8 AOM
  * \ingroup codecs
- * VP8 is aom's newest video compression algorithm that uses motion
+ * AOM is aom's newest video compression algorithm that uses motion
  * compensated prediction, Discrete Cosine Transform (DCT) coding of the
  * prediction error signal and context dependent entropy coding techniques
  * based on arithmetic principles. It features:
@@ -26,10 +26,10 @@
  * @{
  */
 /*!\file
- * \brief Provides controls common to both the VP8 encoder and decoder.
+ * \brief Provides controls common to both the AOM encoder and decoder.
  */
-#ifndef AOM_VP8_H_
-#define AOM_VP8_H_
+#ifndef AOM_AOM_H_
+#define AOM_AOM_H_
 
 #include "./aom_codec.h"
 #include "./aom_image.h"
@@ -40,51 +40,51 @@
 
 /*!\brief Control functions
  *
- * The set of macros define the control functions of VP8 interface
+ * The set of macros define the control functions of AOM interface
  */
 enum vp8_com_control_id {
-  VP8_SET_REFERENCE =
+  AOM_SET_REFERENCE =
       1, /**< pass in an external frame into decoder to be used as reference
             frame */
-  VP8_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */
-  VP8_SET_POSTPROC = 3,   /**< set the decoder's post processing settings  */
-  VP8_SET_DBG_COLOR_REF_FRAME =
+  AOM_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */
+  AOM_SET_POSTPROC = 3,   /**< set the decoder's post processing settings  */
+  AOM_SET_DBG_COLOR_REF_FRAME =
       4, /**< set the reference frames to color for each macroblock */
-  VP8_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */
-  VP8_SET_DBG_COLOR_B_MODES = 6,  /**< set which blocks modes to color */
-  VP8_SET_DBG_DISPLAY_MV = 7,     /**< set which motion vector modes to draw */
+  AOM_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */
+  AOM_SET_DBG_COLOR_B_MODES = 6,  /**< set which blocks modes to color */
+  AOM_SET_DBG_DISPLAY_MV = 7,     /**< set which motion vector modes to draw */
 
   /* TODO(jkoleszar): The encoder incorrectly reuses some of these values (5+)
    * for its control ids. These should be migrated to something like the
-   * VP8_DECODER_CTRL_ID_START range next time we're ready to break the ABI.
+   * AOM_DECODER_CTRL_ID_START range next time we're ready to break the ABI.
    */
   VP9_GET_REFERENCE = 128, /**< get a pointer to a reference frame */
-  VP8_COMMON_CTRL_ID_MAX,
-  VP8_DECODER_CTRL_ID_START = 256
+  AOM_COMMON_CTRL_ID_MAX,
+  AOM_DECODER_CTRL_ID_START = 256
 };
 
 /*!\brief post process flags
  *
- * The set of macros define VP8 decoder post processing flags
+ * The set of macros define AOM decoder post processing flags
  */
 enum vp8_postproc_level {
-  VP8_NOFILTERING = 0,
-  VP8_DEBLOCK = 1 << 0,
-  VP8_DEMACROBLOCK = 1 << 1,
-  VP8_ADDNOISE = 1 << 2,
-  VP8_DEBUG_TXT_FRAME_INFO = 1 << 3, /**< print frame information */
-  VP8_DEBUG_TXT_MBLK_MODES =
+  AOM_NOFILTERING = 0,
+  AOM_DEBLOCK = 1 << 0,
+  AOM_DEMACROBLOCK = 1 << 1,
+  AOM_ADDNOISE = 1 << 2,
+  AOM_DEBUG_TXT_FRAME_INFO = 1 << 3, /**< print frame information */
+  AOM_DEBUG_TXT_MBLK_MODES =
       1 << 4, /**< print macro block modes over each macro block */
-  VP8_DEBUG_TXT_DC_DIFF = 1 << 5,   /**< print dc diff for each macro block */
-  VP8_DEBUG_TXT_RATE_INFO = 1 << 6, /**< print video rate info (encoder only) */
-  VP8_MFQE = 1 << 10
+  AOM_DEBUG_TXT_DC_DIFF = 1 << 5,   /**< print dc diff for each macro block */
+  AOM_DEBUG_TXT_RATE_INFO = 1 << 6, /**< print video rate info (encoder only) */
+  AOM_MFQE = 1 << 10
 };
 
 /*!\brief post process flags
  *
  * This define a structure that describe the post processing settings. For
  * the best objective measure (using the PSNR metric) set post_proc_flag
- * to VP8_DEBLOCK and deblocking_level to 1.
+ * to AOM_DEBLOCK and deblocking_level to 1.
  */
 
 typedef struct vp8_postproc_cfg {
@@ -96,12 +96,12 @@
 
 /*!\brief reference frame type
  *
- * The set of macros define the type of VP8 reference frames
+ * The set of macros define the type of AOM reference frames
  */
 typedef enum aom_ref_frame_type {
-  VP8_LAST_FRAME = 1,
-  VP8_GOLD_FRAME = 2,
-  VP8_ALTR_FRAME = 4
+  AOM_LAST_FRAME = 1,
+  AOM_GOLD_FRAME = 2,
+  AOM_ALTR_FRAME = 4
 } aom_ref_frame_type_t;
 
 /*!\brief reference frame data struct
@@ -125,22 +125,22 @@
 /*!\cond */
 /*!\brief vp8 decoder control function parameter type
  *
- * defines the data type for each of VP8 decoder control function requires
+ * defines the data type for each of AOM decoder control function requires
  */
-AOM_CTRL_USE_TYPE(VP8_SET_REFERENCE, aom_ref_frame_t *)
-#define AOM_CTRL_VP8_SET_REFERENCE
-AOM_CTRL_USE_TYPE(VP8_COPY_REFERENCE, aom_ref_frame_t *)
-#define AOM_CTRL_VP8_COPY_REFERENCE
-AOM_CTRL_USE_TYPE(VP8_SET_POSTPROC, vp8_postproc_cfg_t *)
-#define AOM_CTRL_VP8_SET_POSTPROC
-AOM_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_REF_FRAME, int)
-#define AOM_CTRL_VP8_SET_DBG_COLOR_REF_FRAME
-AOM_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_MB_MODES, int)
-#define AOM_CTRL_VP8_SET_DBG_COLOR_MB_MODES
-AOM_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_B_MODES, int)
-#define AOM_CTRL_VP8_SET_DBG_COLOR_B_MODES
-AOM_CTRL_USE_TYPE(VP8_SET_DBG_DISPLAY_MV, int)
-#define AOM_CTRL_VP8_SET_DBG_DISPLAY_MV
+AOM_CTRL_USE_TYPE(AOM_SET_REFERENCE, aom_ref_frame_t *)
+#define AOM_CTRL_AOM_SET_REFERENCE
+AOM_CTRL_USE_TYPE(AOM_COPY_REFERENCE, aom_ref_frame_t *)
+#define AOM_CTRL_AOM_COPY_REFERENCE
+AOM_CTRL_USE_TYPE(AOM_SET_POSTPROC, vp8_postproc_cfg_t *)
+#define AOM_CTRL_AOM_SET_POSTPROC
+AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_REF_FRAME, int)
+#define AOM_CTRL_AOM_SET_DBG_COLOR_REF_FRAME
+AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_MB_MODES, int)
+#define AOM_CTRL_AOM_SET_DBG_COLOR_MB_MODES
+AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_B_MODES, int)
+#define AOM_CTRL_AOM_SET_DBG_COLOR_B_MODES
+AOM_CTRL_USE_TYPE(AOM_SET_DBG_DISPLAY_MV, int)
+#define AOM_CTRL_AOM_SET_DBG_DISPLAY_MV
 AOM_CTRL_USE_TYPE(VP9_GET_REFERENCE, vp9_ref_frame_t *)
 #define AOM_CTRL_VP9_GET_REFERENCE
 
@@ -151,4 +151,4 @@
 }  // extern "C"
 #endif
 
-#endif  // AOM_VP8_H_
+#endif  // AOM_AOM_H_

diff --git a/aom/vp8cx.h b/aom/vp8cx.h
index 96e661b..600b50c 100644
--- a/aom/vp8cx.h
+++ b/aom/vp8cx.h

@@ -8,10 +8,10 @@
  * 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_VP8CX_H_
-#define AOM_VP8CX_H_
+#ifndef AOM_AOMCX_H_
+#define AOM_AOMCX_H_
 
-/*!\defgroup vp8_encoder WebM VP8/VP9 Encoder
+/*!\defgroup vp8_encoder WebM AOM/VP9 Encoder
  * \ingroup vp8
  *
  * @{
@@ -20,7 +20,7 @@
 #include "./aom_encoder.h"
 
 /*!\file
- * \brief Provides definitions for using VP8 or VP9 encoder algorithm within the
+ * \brief Provides definitions for using AOM or VP9 encoder algorithm within the
  *        aom Codec Interface.
  */
 
@@ -47,7 +47,7 @@
  * predictor. When not set, the encoder will choose whether to use the
  * last frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_LAST (1 << 16)
+#define AOM_EFLAG_NO_REF_LAST (1 << 16)
 
 /*!\brief Don't reference the golden frame
  *
@@ -55,7 +55,7 @@
  * predictor. When not set, the encoder will choose whether to use the
  * golden frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_GF (1 << 17)
+#define AOM_EFLAG_NO_REF_GF (1 << 17)
 
 /*!\brief Don't reference the alternate reference frame
  *
@@ -63,49 +63,49 @@
  * predictor. When not set, the encoder will choose whether to use the
  * alt ref frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_ARF (1 << 21)
+#define AOM_EFLAG_NO_REF_ARF (1 << 21)
 
 /*!\brief Don't update the last frame
  *
  * When this flag is set, the encoder will not update the last frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_LAST (1 << 18)
+#define AOM_EFLAG_NO_UPD_LAST (1 << 18)
 
 /*!\brief Don't update the golden frame
  *
  * When this flag is set, the encoder will not update the golden frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_GF (1 << 22)
+#define AOM_EFLAG_NO_UPD_GF (1 << 22)
 
 /*!\brief Don't update the alternate reference frame
  *
  * When this flag is set, the encoder will not update the alt ref frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_ARF (1 << 23)
+#define AOM_EFLAG_NO_UPD_ARF (1 << 23)
 
 /*!\brief Force golden frame update
  *
  * When this flag is set, the encoder copy the contents of the current frame
  * to the golden frame buffer.
  */
-#define VP8_EFLAG_FORCE_GF (1 << 19)
+#define AOM_EFLAG_FORCE_GF (1 << 19)
 
 /*!\brief Force alternate reference frame update
  *
  * When this flag is set, the encoder copy the contents of the current frame
  * to the alternate reference frame buffer.
  */
-#define VP8_EFLAG_FORCE_ARF (1 << 24)
+#define AOM_EFLAG_FORCE_ARF (1 << 24)
 
 /*!\brief Disable entropy update
  *
  * When this flag is set, the encoder will not update its internal entropy
  * model based on the entropy of this frame.
  */
-#define VP8_EFLAG_NO_UPD_ENTROPY (1 << 20)
+#define AOM_EFLAG_NO_UPD_ENTROPY (1 << 20)
 
 /*!\brief VPx encoder control functions
  *
@@ -117,21 +117,21 @@
 enum vp8e_enc_control_id {
   /*!\brief Codec control function to pass an ROI map to encoder.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_ROI_MAP = 8,
+  AOME_SET_ROI_MAP = 8,
 
   /*!\brief Codec control function to pass an Active map to encoder.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_ACTIVEMAP,
+  AOME_SET_ACTIVEMAP,
 
   /*!\brief Codec control function to set encoder scaling mode.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_SCALEMODE = 11,
+  AOME_SET_SCALEMODE = 11,
 
   /*!\brief Codec control function to set encoder internal speed settings.
    *
@@ -139,83 +139,83 @@
    * of motion estimation methods. Values greater than 0 will increase encoder
    * speed at the expense of quality.
    *
-   * \note Valid range for VP8: -16..16
+   * \note Valid range for AOM: -16..16
    * \note Valid range for VP9: -8..8
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_CPUUSED = 13,
+  AOME_SET_CPUUSED = 13,
 
   /*!\brief Codec control function to enable automatic set and use alf frames.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_ENABLEAUTOALTREF,
+  AOME_SET_ENABLEAUTOALTREF,
 
   /*!\brief control function to set noise sensitivity
    *
    * 0: off, 1: OnYOnly, 2: OnYUV,
    * 3: OnYUVAggressive, 4: Adaptive
    *
-   * Supported in codecs: VP8
+   * Supported in codecs: AOM
    */
-  VP8E_SET_NOISE_SENSITIVITY,
+  AOME_SET_NOISE_SENSITIVITY,
 
   /*!\brief Codec control function to set sharpness.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_SHARPNESS,
+  AOME_SET_SHARPNESS,
 
   /*!\brief Codec control function to set the threshold for MBs treated static.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_STATIC_THRESHOLD,
+  AOME_SET_STATIC_THRESHOLD,
 
   /*!\brief Codec control function to set the number of token partitions.
    *
-   * Supported in codecs: VP8
+   * Supported in codecs: AOM
    */
-  VP8E_SET_TOKEN_PARTITIONS,
+  AOME_SET_TOKEN_PARTITIONS,
 
   /*!\brief Codec control function to get last quantizer chosen by the encoder.
    *
    * Return value uses internal quantizer scale defined by the codec.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_GET_LAST_QUANTIZER,
+  AOME_GET_LAST_QUANTIZER,
 
   /*!\brief Codec control function to get last quantizer chosen by the encoder.
    *
    * Return value uses the 0..63 scale as used by the rc_*_quantizer config
    * parameters.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_GET_LAST_QUANTIZER_64,
+  AOME_GET_LAST_QUANTIZER_64,
 
   /*!\brief Codec control function to set the max no of frames to create arf.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_ARNR_MAXFRAMES,
+  AOME_SET_ARNR_MAXFRAMES,
 
   /*!\brief Codec control function to set the filter strength for the arf.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_ARNR_STRENGTH,
+  AOME_SET_ARNR_STRENGTH,
 
   /*!\deprecated control function to set the filter type to use for the arf. */
-  VP8E_SET_ARNR_TYPE,
+  AOME_SET_ARNR_TYPE,
 
   /*!\brief Codec control function to set visual tuning.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_TUNING,
+  AOME_SET_TUNING,
 
   /*!\brief Codec control function to set constrained quality level.
    *
@@ -223,9 +223,9 @@
    *            set to #AOM_CQ.
    * \note Valid range: 0..63
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_CQ_LEVEL,
+  AOME_SET_CQ_LEVEL,
 
   /*!\brief Codec control function to set Max data rate for Intra frames.
    *
@@ -238,15 +238,15 @@
    * For example, to allocate no more than 4.5 frames worth of bitrate
    * to a keyframe, set this to 450.
    *
-   * Supported in codecs: VP8, VP9
+   * Supported in codecs: AOM, VP9
    */
-  VP8E_SET_MAX_INTRA_BITRATE_PCT,
+  AOME_SET_MAX_INTRA_BITRATE_PCT,
 
   /*!\brief Codec control function to set reference and update frame flags.
    *
-   *  Supported in codecs: VP8
+   *  Supported in codecs: AOM
    */
-  VP8E_SET_FRAME_FLAGS,
+  AOME_SET_FRAME_FLAGS,
 
   /*!\brief Codec control function to set max data rate for Inter frames.
    *
@@ -285,17 +285,17 @@
    * for every frame prior to encoding. The usage of this control function
    * supersedes the internal temporal pattern counter, which is now deprecated.
    *
-   * Supported in codecs: VP8
+   * Supported in codecs: AOM
    */
-  VP8E_SET_TEMPORAL_LAYER_ID,
+  AOME_SET_TEMPORAL_LAYER_ID,
 
   /*!\brief Codec control function to set encoder screen content mode.
    *
    * 0: off, 1: On, 2: On with more aggressive rate control.
    *
-   * Supported in codecs: VP8
+   * Supported in codecs: AOM
    */
-  VP8E_SET_SCREEN_CONTENT_MODE,
+  AOME_SET_SCREEN_CONTENT_MODE,
 
   /*!\brief Codec control function to set lossless encoding mode.
    *
@@ -578,10 +578,10 @@
  * This set of constants define 1-D aom scaling modes
  */
 typedef enum aom_scaling_mode_1d {
-  VP8E_NORMAL = 0,
-  VP8E_FOURFIVE = 1,
-  VP8E_THREEFIVE = 2,
-  VP8E_ONETWO = 3
+  AOME_NORMAL = 0,
+  AOME_FOURFIVE = 1,
+  AOME_THREEFIVE = 2,
+  AOME_ONETWO = 3
 } AOM_SCALING_MODE;
 
 /*!\brief Temporal layering mode enum for VP9 SVC.
@@ -655,18 +655,18 @@
   AOM_SCALING_MODE v_scaling_mode; /**< vertical scaling mode   */
 } aom_scaling_mode_t;
 
-/*!\brief VP8 token partition mode
+/*!\brief AOM token partition mode
  *
- * This defines VP8 partitioning mode for compressed data, i.e., the number of
+ * This defines AOM partitioning mode for compressed data, i.e., the number of
  * sub-streams in the bitstream. Used for parallelized decoding.
  *
  */
 
 typedef enum {
-  VP8_ONE_TOKENPARTITION = 0,
-  VP8_TWO_TOKENPARTITION = 1,
-  VP8_FOUR_TOKENPARTITION = 2,
-  VP8_EIGHT_TOKENPARTITION = 3
+  AOM_ONE_TOKENPARTITION = 0,
+  AOM_TWO_TOKENPARTITION = 1,
+  AOM_FOUR_TOKENPARTITION = 2,
+  AOM_EIGHT_TOKENPARTITION = 3
 } vp8e_token_partitions;
 
 /*!brief VP9 encoder content type */
@@ -676,7 +676,7 @@
   AOM_CONTENT_INVALID
 } aom_tune_content;
 
-/*!\brief VP8 model tuning parameters
+/*!\brief AOM model tuning parameters
  *
  * Changes the encoder to tune for certain types of input material.
  *
@@ -711,23 +711,23 @@
 } aom_svc_ref_frame_config_t;
 
 /*!\cond */
-/*!\brief VP8 encoder control function parameter type
+/*!\brief AOM encoder control function parameter type
  *
- * Defines the data types that VP8E control functions take. Note that
+ * Defines the data types that AOME control functions take. Note that
  * additional common controls are defined in vp8.h
  *
  */
 
-AOM_CTRL_USE_TYPE(VP8E_SET_FRAME_FLAGS, int)
-#define AOM_CTRL_VP8E_SET_FRAME_FLAGS
-AOM_CTRL_USE_TYPE(VP8E_SET_TEMPORAL_LAYER_ID, int)
-#define AOM_CTRL_VP8E_SET_TEMPORAL_LAYER_ID
-AOM_CTRL_USE_TYPE(VP8E_SET_ROI_MAP, aom_roi_map_t *)
-#define AOM_CTRL_VP8E_SET_ROI_MAP
-AOM_CTRL_USE_TYPE(VP8E_SET_ACTIVEMAP, aom_active_map_t *)
-#define AOM_CTRL_VP8E_SET_ACTIVEMAP
-AOM_CTRL_USE_TYPE(VP8E_SET_SCALEMODE, aom_scaling_mode_t *)
-#define AOM_CTRL_VP8E_SET_SCALEMODE
+AOM_CTRL_USE_TYPE(AOME_SET_FRAME_FLAGS, int)
+#define AOM_CTRL_AOME_SET_FRAME_FLAGS
+AOM_CTRL_USE_TYPE(AOME_SET_TEMPORAL_LAYER_ID, int)
+#define AOM_CTRL_AOME_SET_TEMPORAL_LAYER_ID
+AOM_CTRL_USE_TYPE(AOME_SET_ROI_MAP, aom_roi_map_t *)
+#define AOM_CTRL_AOME_SET_ROI_MAP
+AOM_CTRL_USE_TYPE(AOME_SET_ACTIVEMAP, aom_active_map_t *)
+#define AOM_CTRL_AOME_SET_ACTIVEMAP
+AOM_CTRL_USE_TYPE(AOME_SET_SCALEMODE, aom_scaling_mode_t *)
+#define AOM_CTRL_AOME_SET_SCALEMODE
 
 AOM_CTRL_USE_TYPE(VP9E_SET_SVC, int)
 #define AOM_CTRL_VP9E_SET_SVC
@@ -738,49 +738,49 @@
 AOM_CTRL_USE_TYPE(VP9E_SET_SVC_LAYER_ID, aom_svc_layer_id_t *)
 #define AOM_CTRL_VP9E_SET_SVC_LAYER_ID
 
-AOM_CTRL_USE_TYPE(VP8E_SET_CPUUSED, int)
-#define AOM_CTRL_VP8E_SET_CPUUSED
-AOM_CTRL_USE_TYPE(VP8E_SET_ENABLEAUTOALTREF, unsigned int)
-#define AOM_CTRL_VP8E_SET_ENABLEAUTOALTREF
-AOM_CTRL_USE_TYPE(VP8E_SET_NOISE_SENSITIVITY, unsigned int)
-#define AOM_CTRL_VP8E_SET_NOISE_SENSITIVITY
-AOM_CTRL_USE_TYPE(VP8E_SET_SHARPNESS, unsigned int)
-#define AOM_CTRL_VP8E_SET_SHARPNESS
-AOM_CTRL_USE_TYPE(VP8E_SET_STATIC_THRESHOLD, unsigned int)
-#define AOM_CTRL_VP8E_SET_STATIC_THRESHOLD
-AOM_CTRL_USE_TYPE(VP8E_SET_TOKEN_PARTITIONS, int) /* vp8e_token_partitions */
-#define AOM_CTRL_VP8E_SET_TOKEN_PARTITIONS
+AOM_CTRL_USE_TYPE(AOME_SET_CPUUSED, int)
+#define AOM_CTRL_AOME_SET_CPUUSED
+AOM_CTRL_USE_TYPE(AOME_SET_ENABLEAUTOALTREF, unsigned int)
+#define AOM_CTRL_AOME_SET_ENABLEAUTOALTREF
+AOM_CTRL_USE_TYPE(AOME_SET_NOISE_SENSITIVITY, unsigned int)
+#define AOM_CTRL_AOME_SET_NOISE_SENSITIVITY
+AOM_CTRL_USE_TYPE(AOME_SET_SHARPNESS, unsigned int)
+#define AOM_CTRL_AOME_SET_SHARPNESS
+AOM_CTRL_USE_TYPE(AOME_SET_STATIC_THRESHOLD, unsigned int)
+#define AOM_CTRL_AOME_SET_STATIC_THRESHOLD
+AOM_CTRL_USE_TYPE(AOME_SET_TOKEN_PARTITIONS, int) /* vp8e_token_partitions */
+#define AOM_CTRL_AOME_SET_TOKEN_PARTITIONS
 
-AOM_CTRL_USE_TYPE(VP8E_SET_ARNR_MAXFRAMES, unsigned int)
-#define AOM_CTRL_VP8E_SET_ARNR_MAXFRAMES
-AOM_CTRL_USE_TYPE(VP8E_SET_ARNR_STRENGTH, unsigned int)
-#define AOM_CTRL_VP8E_SET_ARNR_STRENGTH
-AOM_CTRL_USE_TYPE_DEPRECATED(VP8E_SET_ARNR_TYPE, unsigned int)
-#define AOM_CTRL_VP8E_SET_ARNR_TYPE
-AOM_CTRL_USE_TYPE(VP8E_SET_TUNING, int) /* aom_tune_metric */
-#define AOM_CTRL_VP8E_SET_TUNING
-AOM_CTRL_USE_TYPE(VP8E_SET_CQ_LEVEL, unsigned int)
-#define AOM_CTRL_VP8E_SET_CQ_LEVEL
+AOM_CTRL_USE_TYPE(AOME_SET_ARNR_MAXFRAMES, unsigned int)
+#define AOM_CTRL_AOME_SET_ARNR_MAXFRAMES
+AOM_CTRL_USE_TYPE(AOME_SET_ARNR_STRENGTH, unsigned int)
+#define AOM_CTRL_AOME_SET_ARNR_STRENGTH
+AOM_CTRL_USE_TYPE_DEPRECATED(AOME_SET_ARNR_TYPE, unsigned int)
+#define AOM_CTRL_AOME_SET_ARNR_TYPE
+AOM_CTRL_USE_TYPE(AOME_SET_TUNING, int) /* aom_tune_metric */
+#define AOM_CTRL_AOME_SET_TUNING
+AOM_CTRL_USE_TYPE(AOME_SET_CQ_LEVEL, unsigned int)
+#define AOM_CTRL_AOME_SET_CQ_LEVEL
 
 AOM_CTRL_USE_TYPE(VP9E_SET_TILE_COLUMNS, int)
 #define AOM_CTRL_VP9E_SET_TILE_COLUMNS
 AOM_CTRL_USE_TYPE(VP9E_SET_TILE_ROWS, int)
 #define AOM_CTRL_VP9E_SET_TILE_ROWS
 
-AOM_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER, int *)
-#define AOM_CTRL_VP8E_GET_LAST_QUANTIZER
-AOM_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER_64, int *)
-#define AOM_CTRL_VP8E_GET_LAST_QUANTIZER_64
+AOM_CTRL_USE_TYPE(AOME_GET_LAST_QUANTIZER, int *)
+#define AOM_CTRL_AOME_GET_LAST_QUANTIZER
+AOM_CTRL_USE_TYPE(AOME_GET_LAST_QUANTIZER_64, int *)
+#define AOM_CTRL_AOME_GET_LAST_QUANTIZER_64
 AOM_CTRL_USE_TYPE(VP9E_GET_SVC_LAYER_ID, aom_svc_layer_id_t *)
 #define AOM_CTRL_VP9E_GET_SVC_LAYER_ID
 
-AOM_CTRL_USE_TYPE(VP8E_SET_MAX_INTRA_BITRATE_PCT, unsigned int)
-#define AOM_CTRL_VP8E_SET_MAX_INTRA_BITRATE_PCT
-AOM_CTRL_USE_TYPE(VP8E_SET_MAX_INTER_BITRATE_PCT, unsigned int)
-#define AOM_CTRL_VP8E_SET_MAX_INTER_BITRATE_PCT
+AOM_CTRL_USE_TYPE(AOME_SET_MAX_INTRA_BITRATE_PCT, unsigned int)
+#define AOM_CTRL_AOME_SET_MAX_INTRA_BITRATE_PCT
+AOM_CTRL_USE_TYPE(AOME_SET_MAX_INTER_BITRATE_PCT, unsigned int)
+#define AOM_CTRL_AOME_SET_MAX_INTER_BITRATE_PCT
 
-AOM_CTRL_USE_TYPE(VP8E_SET_SCREEN_CONTENT_MODE, unsigned int)
-#define AOM_CTRL_VP8E_SET_SCREEN_CONTENT_MODE
+AOM_CTRL_USE_TYPE(AOME_SET_SCREEN_CONTENT_MODE, unsigned int)
+#define AOM_CTRL_AOME_SET_SCREEN_CONTENT_MODE
 
 AOM_CTRL_USE_TYPE(VP9E_SET_GF_CBR_BOOST_PCT, unsigned int)
 #define AOM_CTRL_VP9E_SET_GF_CBR_BOOST_PCT
@@ -841,4 +841,4 @@
 }  // extern "C"
 #endif
 
-#endif  // AOM_VP8CX_H_
+#endif  // AOM_AOMCX_H_

diff --git a/aom/vp8dx.h b/aom/vp8dx.h
index d72a9f0..1f6a844 100644
--- a/aom/vp8dx.h
+++ b/aom/vp8dx.h

@@ -9,17 +9,17 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
-/*!\defgroup vp8_decoder WebM VP8/VP9 Decoder
+/*!\defgroup vp8_decoder WebM AOM/VP9 Decoder
  * \ingroup vp8
  *
  * @{
  */
 /*!\file
- * \brief Provides definitions for using VP8 or VP9 within the aom Decoder
+ * \brief Provides definitions for using AOM or VP9 within the aom Decoder
  *        interface.
  */
-#ifndef AOM_VP8DX_H_
-#define AOM_VP8DX_H_
+#ifndef AOM_AOMDX_H_
+#define AOM_AOMDX_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -38,9 +38,9 @@
 /*!@} - end algorithm interface member group*/
 
 /*!\enum vp8_dec_control_id
- * \brief VP8 decoder control functions
+ * \brief AOM decoder control functions
  *
- * This set of macros define the control functions available for the VP8
+ * This set of macros define the control functions available for the AOM
  * decoder interface.
  *
  * \sa #aom_codec_control
@@ -49,22 +49,22 @@
   /** control function to get info on which reference frames were updated
    *  by the last decode
    */
-  VP8D_GET_LAST_REF_UPDATES = VP8_DECODER_CTRL_ID_START,
+  AOMD_GET_LAST_REF_UPDATES = AOM_DECODER_CTRL_ID_START,
 
   /** check if the indicated frame is corrupted */
-  VP8D_GET_FRAME_CORRUPTED,
+  AOMD_GET_FRAME_CORRUPTED,
 
   /** control function to get info on which reference frames were used
    *  by the last decode
    */
-  VP8D_GET_LAST_REF_USED,
+  AOMD_GET_LAST_REF_USED,
 
   /** decryption function to decrypt encoded buffer data immediately
    * before decoding. Takes a aom_decrypt_init, which contains
    * a callback function and opaque context pointer.
    */
   AOMD_SET_DECRYPTOR,
-  VP8D_SET_DECRYPTOR = AOMD_SET_DECRYPTOR,
+ // AOMD_SET_DECRYPTOR = AOMD_SET_DECRYPTOR,
 
   /** control function to get the dimensions that the current frame is decoded
    * at. This may be different to the intended display size for the frame as
@@ -103,7 +103,7 @@
    */
   VP9_SET_SKIP_LOOP_FILTER,
 
-  VP8_DECODER_CTRL_ID_MAX
+  AOM_DECODER_CTRL_ID_MAX
 };
 
 /** Decrypt n bytes of data from input -> output, using the decrypt_state
@@ -129,23 +129,23 @@
 typedef aom_decrypt_init vp8_decrypt_init;
 
 /*!\cond */
-/*!\brief VP8 decoder control function parameter type
+/*!\brief AOM decoder control function parameter type
  *
- * Defines the data types that VP8D control functions take. Note that
+ * Defines the data types that AOMD control functions take. Note that
  * additional common controls are defined in vp8.h
  *
  */
 
-AOM_CTRL_USE_TYPE(VP8D_GET_LAST_REF_UPDATES, int *)
-#define AOM_CTRL_VP8D_GET_LAST_REF_UPDATES
-AOM_CTRL_USE_TYPE(VP8D_GET_FRAME_CORRUPTED, int *)
-#define AOM_CTRL_VP8D_GET_FRAME_CORRUPTED
-AOM_CTRL_USE_TYPE(VP8D_GET_LAST_REF_USED, int *)
-#define AOM_CTRL_VP8D_GET_LAST_REF_USED
+AOM_CTRL_USE_TYPE(AOMD_GET_LAST_REF_UPDATES, int *)
+#define AOM_CTRL_AOMD_GET_LAST_REF_UPDATES
+AOM_CTRL_USE_TYPE(AOMD_GET_FRAME_CORRUPTED, int *)
+#define AOM_CTRL_AOMD_GET_FRAME_CORRUPTED
+AOM_CTRL_USE_TYPE(AOMD_GET_LAST_REF_USED, int *)
+#define AOM_CTRL_AOMD_GET_LAST_REF_USED
 AOM_CTRL_USE_TYPE(AOMD_SET_DECRYPTOR, aom_decrypt_init *)
 #define AOM_CTRL_AOMD_SET_DECRYPTOR
-AOM_CTRL_USE_TYPE(VP8D_SET_DECRYPTOR, aom_decrypt_init *)
-#define AOM_CTRL_VP8D_SET_DECRYPTOR
+//AOM_CTRL_USE_TYPE(AOMD_SET_DECRYPTOR, aom_decrypt_init *)
+//#define AOM_CTRL_AOMD_SET_DECRYPTOR
 AOM_CTRL_USE_TYPE(VP9D_GET_DISPLAY_SIZE, int *)
 #define AOM_CTRL_VP9D_GET_DISPLAY_SIZE
 AOM_CTRL_USE_TYPE(VP9D_GET_BIT_DEPTH, unsigned int *)
@@ -162,4 +162,4 @@
 }  // extern "C"
 #endif
 
-#endif  // AOM_VP8DX_H_
+#endif  // AOM_AOMDX_H_

diff --git a/aom_scale/yv12config.h b/aom_scale/yv12config.h
index 9f91567..89677e5 100644
--- a/aom_scale/yv12config.h
+++ b/aom_scale/yv12config.h

@@ -21,7 +21,7 @@
 #include "aom/aom_frame_buffer.h"
 #include "aom/aom_integer.h"
 
-#define VP8BORDERINPIXELS 32
+#define AOMBORDERINPIXELS 32
 #define AOMINNERBORDERINPIXELS 96
 #define AOM_INTERP_EXTEND 4
 #define AOM_ENC_BORDER_IN_PIXELS 160

diff --git a/aomdec.c b/aomdec.c
index 39a6377..71794a9 100644
--- a/aomdec.c
+++ b/aomdec.c

@@ -753,8 +753,8 @@
     dx_time += (unsigned int)aom_usec_timer_elapsed(&timer);
 
     if (!frame_parallel &&
-        aom_codec_control(&decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted)) {
-      warn("Failed VP8_GET_FRAME_CORRUPTED: %s", aom_codec_error(&decoder));
+        aom_codec_control(&decoder, AOMD_GET_FRAME_CORRUPTED, &corrupted)) {
+      warn("Failed AOM_GET_FRAME_CORRUPTED: %s", aom_codec_error(&decoder));
       if (!keep_going) goto fail;
     }
     frames_corrupted += corrupted;

diff --git a/aomenc.c b/aomenc.c
index 11a1566..b71c3c9 100644
--- a/aomenc.c
+++ b/aomenc.c

@@ -450,12 +450,12 @@
   &min_gf_interval,         &max_gf_interval,  NULL
 };
 static const int av1_arg_ctrl_map[] = {
-  VP8E_SET_CPUUSED,                 VP8E_SET_ENABLEAUTOALTREF,
-  VP8E_SET_SHARPNESS,               VP8E_SET_STATIC_THRESHOLD,
+  AOME_SET_CPUUSED,                 AOME_SET_ENABLEAUTOALTREF,
+  AOME_SET_SHARPNESS,               AOME_SET_STATIC_THRESHOLD,
   VP9E_SET_TILE_COLUMNS,            VP9E_SET_TILE_ROWS,
-  VP8E_SET_ARNR_MAXFRAMES,          VP8E_SET_ARNR_STRENGTH,
-  VP8E_SET_ARNR_TYPE,               VP8E_SET_TUNING,
-  VP8E_SET_CQ_LEVEL,                VP8E_SET_MAX_INTRA_BITRATE_PCT,
+  AOME_SET_ARNR_MAXFRAMES,          AOME_SET_ARNR_STRENGTH,
+  AOME_SET_ARNR_TYPE,               AOME_SET_TUNING,
+  AOME_SET_CQ_LEVEL,                AOME_SET_MAX_INTRA_BITRATE_PCT,
   VP9E_SET_MAX_INTER_BITRATE_PCT,   VP9E_SET_GF_CBR_BOOST_PCT,
   VP9E_SET_LOSSLESS,
 #if CONFIG_AOM_QM
@@ -1584,7 +1584,7 @@
   if (stream->config.cfg.g_pass != AOM_RC_FIRST_PASS) {
     int q;
 
-    aom_codec_control(&stream->encoder, VP8E_GET_LAST_QUANTIZER_64, &q);
+    aom_codec_control(&stream->encoder, AOME_GET_LAST_QUANTIZER_64, &q);
     ctx_exit_on_error(&stream->encoder, "Failed to read quantizer");
     stream->counts[q]++;
   }

diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index c9cd6b8..c085345 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c

@@ -117,9 +117,9 @@
 
 static AOM_REFFRAME ref_frame_to_av1_reframe(aom_ref_frame_type_t frame) {
   switch (frame) {
-    case VP8_LAST_FRAME: return AOM_LAST_FLAG;
-    case VP8_GOLD_FRAME: return AOM_GOLD_FLAG;
-    case VP8_ALTR_FRAME: return AOM_ALT_FLAG;
+    case AOM_LAST_FRAME: return AOM_LAST_FLAG;
+    case AOM_GOLD_FRAME: return AOM_GOLD_FLAG;
+    case AOM_ALTR_FRAME: return AOM_ALT_FLAG;
   }
   assert(0 && "Invalid Reference Frame");
   return AOM_LAST_FLAG;
@@ -538,14 +538,14 @@
 static aom_codec_err_t ctrl_set_cpuused(aom_codec_alg_priv_t *ctx,
                                         va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.cpu_used = CAST(VP8E_SET_CPUUSED, args);
+  extra_cfg.cpu_used = CAST(AOME_SET_CPUUSED, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
 static aom_codec_err_t ctrl_set_enable_auto_alt_ref(aom_codec_alg_priv_t *ctx,
                                                     va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.enable_auto_alt_ref = CAST(VP8E_SET_ENABLEAUTOALTREF, args);
+  extra_cfg.enable_auto_alt_ref = CAST(AOME_SET_ENABLEAUTOALTREF, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -559,14 +559,14 @@
 static aom_codec_err_t ctrl_set_sharpness(aom_codec_alg_priv_t *ctx,
                                           va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.sharpness = CAST(VP8E_SET_SHARPNESS, args);
+  extra_cfg.sharpness = CAST(AOME_SET_SHARPNESS, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
 static aom_codec_err_t ctrl_set_static_thresh(aom_codec_alg_priv_t *ctx,
                                               va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.static_thresh = CAST(VP8E_SET_STATIC_THRESHOLD, args);
+  extra_cfg.static_thresh = CAST(AOME_SET_STATIC_THRESHOLD, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -587,14 +587,14 @@
 static aom_codec_err_t ctrl_set_arnr_max_frames(aom_codec_alg_priv_t *ctx,
                                                 va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.arnr_max_frames = CAST(VP8E_SET_ARNR_MAXFRAMES, args);
+  extra_cfg.arnr_max_frames = CAST(AOME_SET_ARNR_MAXFRAMES, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
 static aom_codec_err_t ctrl_set_arnr_strength(aom_codec_alg_priv_t *ctx,
                                               va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.arnr_strength = CAST(VP8E_SET_ARNR_STRENGTH, args);
+  extra_cfg.arnr_strength = CAST(AOME_SET_ARNR_STRENGTH, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -608,14 +608,14 @@
 static aom_codec_err_t ctrl_set_tuning(aom_codec_alg_priv_t *ctx,
                                        va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.tuning = CAST(VP8E_SET_TUNING, args);
+  extra_cfg.tuning = CAST(AOME_SET_TUNING, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
 static aom_codec_err_t ctrl_set_cq_level(aom_codec_alg_priv_t *ctx,
                                          va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
-  extra_cfg.cq_level = CAST(VP8E_SET_CQ_LEVEL, args);
+  extra_cfg.cq_level = CAST(AOME_SET_CQ_LEVEL, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -623,7 +623,7 @@
     aom_codec_alg_priv_t *ctx, va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
   extra_cfg.rc_max_intra_bitrate_pct =
-      CAST(VP8E_SET_MAX_INTRA_BITRATE_PCT, args);
+      CAST(AOME_SET_MAX_INTRA_BITRATE_PCT, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -631,7 +631,7 @@
     aom_codec_alg_priv_t *ctx, va_list args) {
   struct av1_extracfg extra_cfg = ctx->extra_cfg;
   extra_cfg.rc_max_inter_bitrate_pct =
-      CAST(VP8E_SET_MAX_INTER_BITRATE_PCT, args);
+      CAST(AOME_SET_MAX_INTER_BITRATE_PCT, args);
   return update_extra_cfg(ctx, &extra_cfg);
 }
 
@@ -936,8 +936,8 @@
   aom_codec_pkt_list_init(&ctx->pkt_list);
 
   // Handle Flags
-  if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF)) ||
-      ((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF))) {
+  if (((flags & AOM_EFLAG_NO_UPD_GF) && (flags & AOM_EFLAG_FORCE_GF)) ||
+      ((flags & AOM_EFLAG_NO_UPD_ARF) && (flags & AOM_EFLAG_FORCE_ARF))) {
     ctx->base.err_detail = "Conflicting flags.";
     return AOM_CODEC_INVALID_PARAM;
   }
@@ -1245,26 +1245,26 @@
 }
 
 static aom_codec_ctrl_fn_map_t encoder_ctrl_maps[] = {
-  { VP8_COPY_REFERENCE, ctrl_copy_reference },
+  { AOM_COPY_REFERENCE, ctrl_copy_reference },
 
   // Setters
-  { VP8_SET_REFERENCE, ctrl_set_reference },
-  { VP8_SET_POSTPROC, ctrl_set_previewpp },
-  { VP8E_SET_ROI_MAP, ctrl_set_roi_map },
-  { VP8E_SET_ACTIVEMAP, ctrl_set_active_map },
-  { VP8E_SET_SCALEMODE, ctrl_set_scale_mode },
-  { VP8E_SET_CPUUSED, ctrl_set_cpuused },
-  { VP8E_SET_ENABLEAUTOALTREF, ctrl_set_enable_auto_alt_ref },
-  { VP8E_SET_SHARPNESS, ctrl_set_sharpness },
-  { VP8E_SET_STATIC_THRESHOLD, ctrl_set_static_thresh },
+  { AOM_SET_REFERENCE, ctrl_set_reference },
+  { AOM_SET_POSTPROC, ctrl_set_previewpp },
+  { AOME_SET_ROI_MAP, ctrl_set_roi_map },
+  { AOME_SET_ACTIVEMAP, ctrl_set_active_map },
+  { AOME_SET_SCALEMODE, ctrl_set_scale_mode },
+  { AOME_SET_CPUUSED, ctrl_set_cpuused },
+  { AOME_SET_ENABLEAUTOALTREF, ctrl_set_enable_auto_alt_ref },
+  { AOME_SET_SHARPNESS, ctrl_set_sharpness },
+  { AOME_SET_STATIC_THRESHOLD, ctrl_set_static_thresh },
   { VP9E_SET_TILE_COLUMNS, ctrl_set_tile_columns },
   { VP9E_SET_TILE_ROWS, ctrl_set_tile_rows },
-  { VP8E_SET_ARNR_MAXFRAMES, ctrl_set_arnr_max_frames },
-  { VP8E_SET_ARNR_STRENGTH, ctrl_set_arnr_strength },
-  { VP8E_SET_ARNR_TYPE, ctrl_set_arnr_type },
-  { VP8E_SET_TUNING, ctrl_set_tuning },
-  { VP8E_SET_CQ_LEVEL, ctrl_set_cq_level },
-  { VP8E_SET_MAX_INTRA_BITRATE_PCT, ctrl_set_rc_max_intra_bitrate_pct },
+  { AOME_SET_ARNR_MAXFRAMES, ctrl_set_arnr_max_frames },
+  { AOME_SET_ARNR_STRENGTH, ctrl_set_arnr_strength },
+  { AOME_SET_ARNR_TYPE, ctrl_set_arnr_type },
+  { AOME_SET_TUNING, ctrl_set_tuning },
+  { AOME_SET_CQ_LEVEL, ctrl_set_cq_level },
+  { AOME_SET_MAX_INTRA_BITRATE_PCT, ctrl_set_rc_max_intra_bitrate_pct },
   { VP9E_SET_MAX_INTER_BITRATE_PCT, ctrl_set_rc_max_inter_bitrate_pct },
   { VP9E_SET_GF_CBR_BOOST_PCT, ctrl_set_rc_gf_cbr_boost_pct },
   { VP9E_SET_LOSSLESS, ctrl_set_lossless },
@@ -1286,8 +1286,8 @@
   { VP9E_SET_RENDER_SIZE, ctrl_set_render_size },
 
   // Getters
-  { VP8E_GET_LAST_QUANTIZER, ctrl_get_quantizer },
-  { VP8E_GET_LAST_QUANTIZER_64, ctrl_get_quantizer64 },
+  { AOME_GET_LAST_QUANTIZER, ctrl_get_quantizer },
+  { AOME_GET_LAST_QUANTIZER_64, ctrl_get_quantizer64 },
   { VP9_GET_REFERENCE, ctrl_get_reference },
   { VP9E_GET_ACTIVEMAP, ctrl_get_active_map },
 

diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c
index d56b68e..6c195ba 100644
--- a/av1/av1_dx_iface.c
+++ b/av1/av1_dx_iface.c

@@ -294,7 +294,7 @@
 }
 
 static void set_default_ppflags(vp8_postproc_cfg_t *cfg) {
-  cfg->post_proc_flag = VP8_DEBLOCK | VP8_DEMACROBLOCK;
+  cfg->post_proc_flag = AOM_DEBLOCK | AOM_DEMACROBLOCK;
   cfg->deblocking_level = 4;
   cfg->noise_level = 0;
 }
@@ -1017,23 +1017,23 @@
 }
 
 static aom_codec_ctrl_fn_map_t decoder_ctrl_maps[] = {
-  { VP8_COPY_REFERENCE, ctrl_copy_reference },
+  { AOM_COPY_REFERENCE, ctrl_copy_reference },
 
   // Setters
-  { VP8_SET_REFERENCE, ctrl_set_reference },
-  { VP8_SET_POSTPROC, ctrl_set_postproc },
-  { VP8_SET_DBG_COLOR_REF_FRAME, ctrl_set_dbg_options },
-  { VP8_SET_DBG_COLOR_MB_MODES, ctrl_set_dbg_options },
-  { VP8_SET_DBG_COLOR_B_MODES, ctrl_set_dbg_options },
-  { VP8_SET_DBG_DISPLAY_MV, ctrl_set_dbg_options },
+  { AOM_SET_REFERENCE, ctrl_set_reference },
+  { AOM_SET_POSTPROC, ctrl_set_postproc },
+  { AOM_SET_DBG_COLOR_REF_FRAME, ctrl_set_dbg_options },
+  { AOM_SET_DBG_COLOR_MB_MODES, ctrl_set_dbg_options },
+  { AOM_SET_DBG_COLOR_B_MODES, ctrl_set_dbg_options },
+  { AOM_SET_DBG_DISPLAY_MV, ctrl_set_dbg_options },
   { VP9_INVERT_TILE_DECODE_ORDER, ctrl_set_invert_tile_order },
   { AOMD_SET_DECRYPTOR, ctrl_set_decryptor },
   { VP9_SET_BYTE_ALIGNMENT, ctrl_set_byte_alignment },
   { VP9_SET_SKIP_LOOP_FILTER, ctrl_set_skip_loop_filter },
 
   // Getters
-  { VP8D_GET_LAST_REF_UPDATES, ctrl_get_last_ref_updates },
-  { VP8D_GET_FRAME_CORRUPTED, ctrl_get_frame_corrupted },
+  { AOMD_GET_LAST_REF_UPDATES, ctrl_get_last_ref_updates },
+  { AOMD_GET_FRAME_CORRUPTED, ctrl_get_frame_corrupted },
   { VP9_GET_REFERENCE, ctrl_get_reference },
   { VP9D_GET_DISPLAY_SIZE, ctrl_get_render_size },
   { VP9D_GET_BIT_DEPTH, ctrl_get_bit_depth },

diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 4e7ad21..686969d 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c

@@ -4109,33 +4109,33 @@
 
 void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags) {
   if (flags &
-      (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
+      (AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF)) {
     int ref = 7;
 
-    if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= AOM_LAST_FLAG;
+    if (flags & AOM_EFLAG_NO_REF_LAST) ref ^= AOM_LAST_FLAG;
 
-    if (flags & VP8_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG;
+    if (flags & AOM_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG;
 
-    if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= AOM_ALT_FLAG;
+    if (flags & AOM_EFLAG_NO_REF_ARF) ref ^= AOM_ALT_FLAG;
 
     av1_use_as_reference(cpi, ref);
   }
 
   if (flags &
-      (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
-       VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
+      (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF |
+       AOM_EFLAG_FORCE_GF | AOM_EFLAG_FORCE_ARF)) {
     int upd = 7;
 
-    if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG;
+    if (flags & AOM_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG;
 
-    if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG;
+    if (flags & AOM_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG;
 
-    if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= AOM_ALT_FLAG;
+    if (flags & AOM_EFLAG_NO_UPD_ARF) upd ^= AOM_ALT_FLAG;
 
     av1_update_reference(cpi, upd);
   }
 
-  if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
+  if (flags & AOM_EFLAG_NO_UPD_ENTROPY) {
     av1_update_entropy(cpi, 0);
   }
 }

diff --git a/examples/aom_temporal_svc_encoder.c b/examples/aom_temporal_svc_encoder.c
index 7867f9e..86ddb36 100644
--- a/examples/aom_temporal_svc_encoder.c
+++ b/examples/aom_temporal_svc_encoder.c

@@ -175,7 +175,7 @@
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // Update L only.
       layer_flags[0] =
-          AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
       break;
     }
     case 1: {
@@ -189,18 +189,18 @@
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 #if 1
       // 0=L, 1=GF, Intra-layer prediction enabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF;
       layer_flags[1] =
-          VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
+          AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_REF_ARF;
 #else
       // 0=L, 1=GF, Intra-layer prediction disabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF;
-      layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF;
+      layer_flags[1] = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_REF_LAST;
 #endif
       break;
     }
@@ -214,12 +214,12 @@
       cfg->ts_rate_decimator[1] = 1;
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, Intra-layer prediction enabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
       layer_flags[1] = layer_flags[2] =
-          VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
-          VP8_EFLAG_NO_UPD_LAST;
+          AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_ARF |
+          AOM_EFLAG_NO_UPD_LAST;
       break;
     }
     case 3: {
@@ -233,13 +233,13 @@
       cfg->ts_rate_decimator[2] = 1;
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
       layer_flags[3] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       layer_flags[1] = layer_flags[2] = layer_flags[4] = layer_flags[5] =
-          VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
+          AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_LAST;
       break;
     }
     case 4: {
@@ -253,14 +253,14 @@
       cfg->ts_rate_decimator[2] = 1;
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
-      layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
-                       VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
+      layer_flags[2] = AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF |
+                       AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       layer_flags[1] = layer_flags[3] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-          VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+          AOM_EFLAG_NO_UPD_ARF;
       break;
     }
     case 5: {
@@ -275,14 +275,14 @@
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1, disabled
       // in layer 2.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
       layer_flags[2] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ARF;
       layer_flags[1] = layer_flags[3] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-          VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+          AOM_EFLAG_NO_UPD_ARF;
       break;
     }
     case 6: {
@@ -296,13 +296,13 @@
       cfg->ts_rate_decimator[2] = 1;
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
       layer_flags[2] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ARF;
       layer_flags[1] = layer_flags[3] =
-          VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
+          AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF;
       break;
     }
     case 7: {
@@ -321,13 +321,13 @@
       layer_flags[0] = AOM_EFLAG_FORCE_KF;
       layer_flags[1] = layer_flags[3] = layer_flags[5] = layer_flags[7] =
           layer_flags[9] = layer_flags[11] = layer_flags[13] = layer_flags[15] =
-              VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-              VP8_EFLAG_NO_UPD_ARF;
+              AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+              AOM_EFLAG_NO_UPD_ARF;
       layer_flags[2] = layer_flags[6] = layer_flags[10] = layer_flags[14] =
-          VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF;
+          AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_GF;
       layer_flags[4] = layer_flags[12] =
-          VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_ARF;
-      layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF;
+          AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_UPD_ARF;
+      layer_flags[8] = AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_GF;
       break;
     }
     case 8: {
@@ -345,16 +345,16 @@
 
       // Layer 0: predict from L and ARF, update L and G.
       layer_flags[0] =
-          AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_ARF;
       // Layer 1: sync point: predict from L and ARF, and update G.
       layer_flags[1] =
-          VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ARF;
       // Layer 0, predict from L and ARF, update L.
       layer_flags[2] =
-          VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
       // Layer 1: predict from L, G and ARF, and update G.
-      layer_flags[3] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
-                       VP8_EFLAG_NO_UPD_ENTROPY;
+      layer_flags[3] = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST |
+                       AOM_EFLAG_NO_UPD_ENTROPY;
       // Layer 0.
       layer_flags[4] = layer_flags[2];
       // Layer 1.
@@ -376,21 +376,21 @@
       cfg->ts_rate_decimator[2] = 1;
       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
       // 0=L, 1=GF, 2=ARF.
-      layer_flags[0] = AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
-                       VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF;
-      layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
-                       VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
-      layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
-                       VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
+      layer_flags[0] = AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_REF_GF |
+                       AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF;
+      layer_flags[1] = AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF |
+                       AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF;
+      layer_flags[2] = AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF |
+                       AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ARF;
       layer_flags[3] = layer_flags[5] =
-          VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
-      layer_flags[4] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
-                       VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+          AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF;
+      layer_flags[4] = AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF |
+                       AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
       layer_flags[6] =
-          VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
-      layer_flags[7] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ENTROPY;
+          AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ARF;
+      layer_flags[7] = AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_ENTROPY;
       break;
     }
     case 10: {
@@ -409,24 +409,24 @@
       // 0=L, 1=GF, 2=ARF.
       // Layer 0: predict from L and ARF; update L and G.
       layer_flags[0] =
-          AOM_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
+          AOM_EFLAG_FORCE_KF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF;
       // Layer 2: sync point: predict from L and ARF; update none.
-      layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF |
-                       VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
-                       VP8_EFLAG_NO_UPD_ENTROPY;
+      layer_flags[1] = AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_GF |
+                       AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST |
+                       AOM_EFLAG_NO_UPD_ENTROPY;
       // Layer 1: sync point: predict from L and ARF; update G.
       layer_flags[2] =
-          VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+          AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       // Layer 2: predict from L, G, ARF; update none.
-      layer_flags[3] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
-                       VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
+      layer_flags[3] = AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF |
+                       AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ENTROPY;
       // Layer 0: predict from L and ARF; update L.
       layer_flags[4] =
-          VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
+          AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF;
       // Layer 2: predict from L, G, ARF; update none.
       layer_flags[5] = layer_flags[3];
       // Layer 1: predict from L, G, ARF; update G.
-      layer_flags[6] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+      layer_flags[6] = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       // Layer 2: predict from L, G, ARF; update none.
       layer_flags[7] = layer_flags[3];
       break;
@@ -446,14 +446,14 @@
       // 0=L, 1=GF, 2=ARF.
       // Layer 0: predict from L and ARF; update L.
       layer_flags[0] =
-          VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
+          AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF;
       layer_flags[4] = layer_flags[0];
       // Layer 1: predict from L, G, ARF; update G.
-      layer_flags[2] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+      layer_flags[2] = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       layer_flags[6] = layer_flags[2];
       // Layer 2: predict from L, G, ARF; update none.
-      layer_flags[1] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
-                       VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
+      layer_flags[1] = AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF |
+                       AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_ENTROPY;
       layer_flags[3] = layer_flags[1];
       layer_flags[5] = layer_flags[1];
       layer_flags[7] = layer_flags[1];
@@ -677,16 +677,16 @@
     die_codec(&codec, "Failed to initialize encoder");
 
   if (strncmp(encoder->name, "vp8", 3) == 0) {
-    aom_codec_control(&codec, VP8E_SET_CPUUSED, -speed);
-    aom_codec_control(&codec, VP8E_SET_NOISE_SENSITIVITY, kDenoiserOff);
-    aom_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
+    aom_codec_control(&codec, AOME_SET_CPUUSED, -speed);
+    aom_codec_control(&codec, AOME_SET_NOISE_SENSITIVITY, kDenoiserOff);
+    aom_codec_control(&codec, AOME_SET_STATIC_THRESHOLD, 1);
   } else if (strncmp(encoder->name, "vp9", 3) == 0) {
     aom_svc_extra_cfg_t svc_params;
-    aom_codec_control(&codec, VP8E_SET_CPUUSED, speed);
+    aom_codec_control(&codec, AOME_SET_CPUUSED, speed);
     aom_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
     aom_codec_control(&codec, VP9E_SET_FRAME_PERIODIC_BOOST, 0);
     aom_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, 0);
-    aom_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
+    aom_codec_control(&codec, AOME_SET_STATIC_THRESHOLD, 1);
     aom_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0);
     aom_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1));
     if (aom_codec_control(&codec, VP9E_SET_SVC, layering_mode > 0 ? 1 : 0))
@@ -700,15 +700,15 @@
     aom_codec_control(&codec, VP9E_SET_SVC_PARAMETERS, &svc_params);
   }
   if (strncmp(encoder->name, "vp8", 3) == 0) {
-    aom_codec_control(&codec, VP8E_SET_SCREEN_CONTENT_MODE, 0);
+    aom_codec_control(&codec, AOME_SET_SCREEN_CONTENT_MODE, 0);
   }
-  aom_codec_control(&codec, VP8E_SET_TOKEN_PARTITIONS, 1);
+  aom_codec_control(&codec, AOME_SET_TOKEN_PARTITIONS, 1);
   // This controls the maximum target size of the key frame.
   // For generating smaller key frames, use a smaller max_intra_size_pct
   // value, like 100 or 200.
   {
     const int max_intra_size_pct = 900;
-    aom_codec_control(&codec, VP8E_SET_MAX_INTRA_BITRATE_PCT,
+    aom_codec_control(&codec, AOME_SET_MAX_INTRA_BITRATE_PCT,
                       max_intra_size_pct);
   }
 
@@ -726,7 +726,7 @@
     if (strncmp(encoder->name, "vp9", 3) == 0) {
       aom_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id);
     } else if (strncmp(encoder->name, "vp8", 3) == 0) {
-      aom_codec_control(&codec, VP8E_SET_TEMPORAL_LAYER_ID,
+      aom_codec_control(&codec, AOME_SET_TEMPORAL_LAYER_ID,
                         layer_id.temporal_layer_id);
     }
     flags = layer_flags[frame_cnt % flag_periodicity];

diff --git a/examples/set_maps.c b/examples/set_maps.c
index e436be8..14080dd 100644
--- a/examples/set_maps.c
+++ b/examples/set_maps.c

@@ -9,10 +9,10 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
-// VP8 Set Active and ROI Maps
+// AOM Set Active and ROI Maps
 // ===========================
 //
-// This is an example demonstrating how to control the VP8 encoder's
+// This is an example demonstrating how to control the AOM encoder's
 // ROI and Active maps.
 //
 // ROI (Reigon of Interest) maps are a way for the application to assign
@@ -88,7 +88,7 @@
   roi.roi_map = (uint8_t *)malloc(roi.rows * roi.cols);
   for (i = 0; i < roi.rows * roi.cols; ++i) roi.roi_map[i] = i % 4;
 
-  if (aom_codec_control(codec, VP8E_SET_ROI_MAP, &roi))
+  if (aom_codec_control(codec, AOME_SET_ROI_MAP, &roi))
     die_codec(codec, "Failed to set ROI map");
 
   free(roi.roi_map);
@@ -105,7 +105,7 @@
   map.active_map = (uint8_t *)malloc(map.rows * map.cols);
   for (i = 0; i < map.rows * map.cols; ++i) map.active_map[i] = i % 2;
 
-  if (aom_codec_control(codec, VP8E_SET_ACTIVEMAP, &map))
+  if (aom_codec_control(codec, AOME_SET_ACTIVEMAP, &map))
     die_codec(codec, "Failed to set active map");
 
   free(map.active_map);
@@ -119,7 +119,7 @@
   map.cols = (cfg->g_w + 15) / 16;
   map.active_map = NULL;
 
-  if (aom_codec_control(codec, VP8E_SET_ACTIVEMAP, &map))
+  if (aom_codec_control(codec, AOME_SET_ACTIVEMAP, &map))
     die_codec(codec, "Failed to set active map");
 }
 
@@ -216,7 +216,7 @@
   while (aom_img_read(&raw, infile)) {
     ++frame_count;
 
-    if (frame_count == 22 && encoder->fourcc == VP8_FOURCC) {
+    if (frame_count == 22 && encoder->fourcc == AOM_FOURCC) {
       set_roi_map(&cfg, &codec);
     } else if (frame_count == 33) {
       set_active_map(&cfg, &codec);

diff --git a/mainpage.dox b/mainpage.dox
index ec202fa..59b6810 100644
--- a/mainpage.dox
+++ b/mainpage.dox

@@ -7,7 +7,7 @@
 
   \section main_intro Introduction
   Welcome to the WebM Codec SDK. This SDK allows you to integrate your
-  applications with the VP8 and VP9 video codecs, high quality, royalty free,
+  applications with the AOM and VP9 video codecs, high quality, royalty free,
   open source codecs deployed on billions of computers and devices worldwide.
 
   This distribution of the WebM Codec SDK includes the following support:

diff --git a/test/active_map_refresh_test.cc b/test/active_map_refresh_test.cc
index 5b4e690..d660076 100644
--- a/test/active_map_refresh_test.cc
+++ b/test/active_map_refresh_test.cc

@@ -74,7 +74,7 @@
     ::libaom_test::Y4mVideoSource *y4m_video =
         static_cast<libaom_test::Y4mVideoSource *>(video);
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, cpu_used_);
       encoder->Control(VP9E_SET_AQ_MODE, kAqModeCyclicRefresh);
     } else if (video->frame() >= 2 && video->img()) {
       aom_image_t *current = video->img();
@@ -90,7 +90,7 @@
       map.cols = mb_width;
       map.rows = mb_height;
       map.active_map = active_map;
-      encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+      encoder->Control(AOME_SET_ACTIVEMAP, &map);
       delete[] active_map;
     }
     if (video->img()) {

diff --git a/test/active_map_test.cc b/test/active_map_test.cc
index 026d690..1e15147 100644
--- a/test/active_map_test.cc
+++ b/test/active_map_test.cc

@@ -36,7 +36,7 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, cpu_used_);
     } else if (video->frame() == 3) {
       aom_active_map_t map = aom_active_map_t();
       uint8_t active_map[9 * 13] = {
@@ -51,13 +51,13 @@
       ASSERT_EQ(map.cols, 13u);
       ASSERT_EQ(map.rows, 9u);
       map.active_map = active_map;
-      encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+      encoder->Control(AOME_SET_ACTIVEMAP, &map);
     } else if (video->frame() == 15) {
       aom_active_map_t map = aom_active_map_t();
       map.cols = (kWidth + 15) / 16;
       map.rows = (kHeight + 15) / 16;
       map.active_map = NULL;
-      encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+      encoder->Control(AOME_SET_ACTIVEMAP, &map);
     }
   }
 

diff --git a/test/aomdec.sh b/test/aomdec.sh
index c9b5292..fe50bfe 100755
--- a/test/aomdec.sh
+++ b/test/aomdec.sh

@@ -16,7 +16,7 @@
 
 # Environment check: Make sure input is available.
 aomdec_verify_environment() {
-  if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_WEBM_FILE}" ] || \
+  if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_WEBM_FILE}" ] || \
     [ ! -e "${VP9_FPM_WEBM_FILE}" ] || \
     [ ! -e "${VP9_LT_50_FRAMES_WEBM_FILE}" ] ; then
     elog "Libaom test data must exist in LIBAOM_TEST_DATA_PATH."
@@ -63,13 +63,13 @@
 
 aomdec_vp8_ivf() {
   if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
-    aomdec "${VP8_IVF_FILE}" --summary --noblit
+    aomdec "${AOM_IVF_FILE}" --summary --noblit
   fi
 }
 
 aomdec_vp8_ivf_pipe_input() {
   if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
-    aomdec_pipe "${VP8_IVF_FILE}" --summary --noblit
+    aomdec_pipe "${AOM_IVF_FILE}" --summary --noblit
   fi
 }
 

diff --git a/test/aq_segment_test.cc b/test/aq_segment_test.cc
index b7748d4..a7ad942 100644
--- a/test/aq_segment_test.cc
+++ b/test/aq_segment_test.cc

@@ -32,9 +32,9 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
       encoder->Control(VP9E_SET_AQ_MODE, aq_mode_);
-      encoder->Control(VP8E_SET_MAX_INTRA_BITRATE_PCT, 100);
+      encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT, 100);
     }
   }
 

diff --git a/test/arf_freq_test.cc b/test/arf_freq_test.cc
index ab198e6..47dbd6d 100644
--- a/test/arf_freq_test.cc
+++ b/test/arf_freq_test.cc

@@ -147,13 +147,13 @@
     if (video->frame() == 0) {
       encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
       encoder->Control(VP9E_SET_TILE_COLUMNS, 4);
-      encoder->Control(VP8E_SET_CPUUSED, test_encode_param_.cpu_used);
+      encoder->Control(AOME_SET_CPUUSED, test_encode_param_.cpu_used);
       encoder->Control(VP9E_SET_MIN_GF_INTERVAL, min_arf_requested_);
       if (test_encode_param_.mode != ::libaom_test::kRealTime) {
-        encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-        encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-        encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-        encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+        encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+        encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+        encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+        encoder->Control(AOME_SET_ARNR_TYPE, 3);
       }
     }
   }

diff --git a/test/borders_test.cc b/test/borders_test.cc
index cc8a3e9..f80cb30 100644
--- a/test/borders_test.cc
+++ b/test/borders_test.cc

@@ -32,11 +32,11 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, 1);
-      encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-      encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-      encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-      encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+      encoder->Control(AOME_SET_CPUUSED, 1);
+      encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+      encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+      encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+      encoder->Control(AOME_SET_ARNR_TYPE, 3);
     }
   }
 

diff --git a/test/cpu_speed_test.cc b/test/cpu_speed_test.cc
index a7d2459..6656019 100644
--- a/test/cpu_speed_test.cc
+++ b/test/cpu_speed_test.cc

@@ -44,12 +44,12 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
       if (encoding_mode_ != ::libaom_test::kRealTime) {
-        encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-        encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-        encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-        encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+        encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+        encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+        encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+        encoder->Control(AOME_SET_ARNR_TYPE, 3);
       }
     }
   }

diff --git a/test/datarate_test.cc b/test/datarate_test.cc
index a8ee800..dba1baf 100644
--- a/test/datarate_test.cc
+++ b/test/datarate_test.cc

@@ -47,7 +47,7 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 0)
-      encoder->Control(VP8E_SET_NOISE_SENSITIVITY, denoiser_on_);
+      encoder->Control(AOME_SET_NOISE_SENSITIVITY, denoiser_on_);
 
     if (denoiser_offon_test_) {
       ASSERT_GT(denoiser_offon_period_, 0)
@@ -56,7 +56,7 @@
         // Flip denoiser_on_ periodically
         denoiser_on_ ^= 1;
       }
-      encoder->Control(VP8E_SET_NOISE_SENSITIVITY, denoiser_on_);
+      encoder->Control(AOME_SET_NOISE_SENSITIVITY, denoiser_on_);
     }
 
     const aom_rational_t tb = video->timebase();
@@ -308,24 +308,24 @@
       if (frame_num % 2 == 0) {
         // Layer 0: predict from L and ARF, update L.
         frame_flags =
-            VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+            AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
       } else {
         // Layer 1: predict from L, G and ARF, and update G.
-        frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
-                      VP8_EFLAG_NO_UPD_ENTROPY;
+        frame_flags = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST |
+                      AOM_EFLAG_NO_UPD_ENTROPY;
       }
     } else if (num_temp_layers == 3) {
       if (frame_num % 4 == 0) {
         // Layer 0: predict from L and ARF; update L.
         frame_flags =
-            VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
+            AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_REF_GF;
       } else if ((frame_num - 2) % 4 == 0) {
         // Layer 1: predict from L, G, ARF; update G.
-        frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+        frame_flags = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       } else if ((frame_num - 1) % 2 == 0) {
         // Layer 2: predict from L, G, ARF; update none.
         frame_flags =
-            VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+            AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
       }
     }
     return frame_flags;
@@ -353,7 +353,7 @@
 
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
-    if (video->frame() == 0) encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+    if (video->frame() == 0) encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
 
     if (denoiser_offon_test_) {
       ASSERT_GT(denoiser_offon_period_, 0)
@@ -718,9 +718,9 @@
       svc_params_.scaling_factor_den[1] = 288;
       encoder->Control(VP9E_SET_SVC, 1);
       encoder->Control(VP9E_SET_SVC_PARAMETERS, &svc_params_);
-      encoder->Control(VP8E_SET_CPUUSED, speed_setting_);
+      encoder->Control(AOME_SET_CPUUSED, speed_setting_);
       encoder->Control(VP9E_SET_TILE_COLUMNS, 0);
-      encoder->Control(VP8E_SET_MAX_INTRA_BITRATE_PCT, 300);
+      encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT, 300);
       encoder->Control(VP9E_SET_TILE_COLUMNS, (cfg_.g_threads >> 1));
     }
     const aom_rational_t tb = video->timebase();

diff --git a/test/decode_perf_test.cc b/test/decode_perf_test.cc
index 17ed1f1..f0517e6 100644
--- a/test/decode_perf_test.cc
+++ b/test/decode_perf_test.cc

@@ -139,7 +139,7 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, speed_);
+      encoder->Control(AOME_SET_CPUUSED, speed_);
       encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
       encoder->Control(VP9E_SET_TILE_COLUMNS, 2);
     }

diff --git a/test/decode_test_driver.cc b/test/decode_test_driver.cc
index 4c5e31a..131af33 100644
--- a/test/decode_test_driver.cc
+++ b/test/decode_test_driver.cc

@@ -17,7 +17,7 @@
 
 namespace libaom_test {
 
-const char kVP8Name[] = "WebM Project VP8";
+const char kAOMName[] = "WebM Project AOM";
 
 aom_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size,
                                     aom_codec_stream_info_t *stream_info) {
@@ -39,15 +39,15 @@
   return res_dec;
 }
 
-bool Decoder::IsVP8() const {
+bool Decoder::IsAOM() const {
   const char *codec_name = GetDecoderName();
-  return strncmp(kVP8Name, codec_name, sizeof(kVP8Name) - 1) == 0;
+  return strncmp(kAOMName, codec_name, sizeof(kAOMName) - 1) == 0;
 }
 
 void DecoderTest::HandlePeekResult(Decoder *const decoder,
                                    CompressedVideoSource *video,
                                    const aom_codec_err_t res_peek) {
-  const bool is_vp8 = decoder->IsVP8();
+  const bool is_vp8 = decoder->IsAOM();
   if (is_vp8) {
     /* Vp8's implementation of PeekStream returns an error if the frame you
      * pass it is not a keyframe, so we only expect AOM_CODEC_OK on the first

diff --git a/test/decode_test_driver.h b/test/decode_test_driver.h
index 347ff49..a5983c8 100644
--- a/test/decode_test_driver.h
+++ b/test/decode_test_driver.h

@@ -99,7 +99,7 @@
     return aom_codec_iface_name(CodecInterface());
   }
 
-  bool IsVP8() const;
+  bool IsAOM() const;
 
   aom_codec_ctx_t *GetDecoder() { return &decoder_; }
 

diff --git a/test/decode_to_md5.sh b/test/decode_to_md5.sh
index 1c2bd3d..3007c51 100755
--- a/test/decode_to_md5.sh
+++ b/test/decode_to_md5.sh

@@ -16,9 +16,9 @@
 . $(dirname $0)/tools_common.sh
 
 # Environment check: Make sure input is available:
-#   $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+#   $AOM_IVF_FILE and $VP9_IVF_FILE are required.
 decode_to_md5_verify_environment() {
-  if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
+  if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
     echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH."
     return 1
   fi
@@ -54,7 +54,7 @@
   local expected_md5="56794d911b02190212bca92f88ad60c6"
 
   if [ "$(vp8_decode_available)" = "yes" ]; then
-    decode_to_md5 "${VP8_IVF_FILE}" "vp8" "${expected_md5}"
+    decode_to_md5 "${AOM_IVF_FILE}" "vp8" "${expected_md5}"
   fi
 }
 

diff --git a/test/decode_with_drops.sh b/test/decode_with_drops.sh
index 3479e69..9d33825 100755
--- a/test/decode_with_drops.sh
+++ b/test/decode_with_drops.sh

@@ -16,9 +16,9 @@
 . $(dirname $0)/tools_common.sh
 
 # Environment check: Make sure input is available:
-#   $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+#   $AOM_IVF_FILE and $VP9_IVF_FILE are required.
 decode_with_drops_verify_environment() {
-  if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
+  if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
     echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH."
     return 1
   fi
@@ -45,17 +45,17 @@
   [ -e "${output_file}" ] || return 1
 }
 
-# Decodes $VP8_IVF_FILE while dropping frames, twice: once in sequence mode,
+# Decodes $AOM_IVF_FILE while dropping frames, twice: once in sequence mode,
 # and once in pattern mode.
-# Note: This test assumes that $VP8_IVF_FILE has exactly 29 frames, and could
+# Note: This test assumes that $AOM_IVF_FILE has exactly 29 frames, and could
 # break if the file is modified.
 decode_with_drops_vp8() {
   if [ "$(vp8_decode_available)" = "yes" ]; then
     # Test sequence mode: Drop frames 2-28.
-    decode_with_drops "${VP8_IVF_FILE}" "vp8" "2-28"
+    decode_with_drops "${AOM_IVF_FILE}" "vp8" "2-28"
 
     # Test pattern mode: Drop 3 of every 4 frames.
-    decode_with_drops "${VP8_IVF_FILE}" "vp8" "3/4"
+    decode_with_drops "${AOM_IVF_FILE}" "vp8" "3/4"
   fi
 }
 

diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc
index 030dd24..7e552ad 100644
--- a/test/encode_api_test.cc
+++ b/test/encode_api_test.cc

@@ -20,7 +20,7 @@
 
 TEST(EncodeAPI, InvalidParams) {
   static const aom_codec_iface_t *kCodecs[] = {
-#if CONFIG_VP8_ENCODER
+#if CONFIG_AOM_ENCODER
     &aom_codec_vp8_cx_algo,
 #endif
 #if CONFIG_VP9_ENCODER

diff --git a/test/encode_perf_test.cc b/test/encode_perf_test.cc
index 4f19100..ba86c56 100644
--- a/test/encode_perf_test.cc
+++ b/test/encode_perf_test.cc

@@ -86,10 +86,10 @@
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 0) {
       const int log2_tile_columns = 3;
-      encoder->Control(VP8E_SET_CPUUSED, speed_);
+      encoder->Control(AOME_SET_CPUUSED, speed_);
       encoder->Control(VP9E_SET_TILE_COLUMNS, log2_tile_columns);
       encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
-      encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 0);
+      encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
     }
   }
 

diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc
index df03a2c..4d31f93 100644
--- a/test/encode_test_driver.cc
+++ b/test/encode_test_driver.cc

@@ -175,7 +175,7 @@
 
     unsigned long dec_init_flags = 0;  // NOLINT
     // Use fragment decoder if encoder outputs partitions.
-    // NOTE: fragment decoder and partition encoder are only supported by VP8.
+    // NOTE: fragment decoder and partition encoder are only supported by AOM.
     if (init_flags_ & AOM_CODEC_USE_OUTPUT_PARTITION)
       dec_init_flags |= AOM_CODEC_USE_INPUT_FRAGMENTS;
     Decoder *const decoder = codec_->CreateDecoder(dec_cfg, dec_init_flags, 0);

diff --git a/test/encoder_parms_get_to_decoder.cc b/test/encoder_parms_get_to_decoder.cc
index 77fc476..aaedbca 100644
--- a/test/encoder_parms_get_to_decoder.cc
+++ b/test/encoder_parms_get_to_decoder.cc

@@ -82,11 +82,11 @@
                        encode_parms.frame_parallel);
       encoder->Control(VP9E_SET_TILE_ROWS, encode_parms.tile_rows);
       encoder->Control(VP9E_SET_TILE_COLUMNS, encode_parms.tile_cols);
-      encoder->Control(VP8E_SET_CPUUSED, kCpuUsed);
-      encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-      encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-      encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-      encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+      encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
+      encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+      encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+      encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+      encoder->Control(AOME_SET_ARNR_TYPE, 3);
       if (encode_parms.render_size[0] > 0 && encode_parms.render_size[1] > 0)
         encoder->Control(VP9E_SET_RENDER_SIZE, encode_parms.render_size);
     }

diff --git a/test/end_to_end_test.cc b/test/end_to_end_test.cc
index 3dbe3f3..a97e518 100644
--- a/test/end_to_end_test.cc
+++ b/test/end_to_end_test.cc

@@ -116,12 +116,12 @@
     if (video->frame() == 1) {
       encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
       encoder->Control(VP9E_SET_TILE_COLUMNS, 4);
-      encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, cpu_used_);
       if (encoding_mode_ != ::libaom_test::kRealTime) {
-        encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-        encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-        encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-        encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+        encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+        encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+        encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+        encoder->Control(AOME_SET_ARNR_TYPE, 3);
       }
     }
   }

diff --git a/test/error_resilience_test.cc b/test/error_resilience_test.cc
index eb5336b..f36f364 100644
--- a/test/error_resilience_test.cc
+++ b/test/error_resilience_test.cc

@@ -70,20 +70,20 @@
         if (frame_num < pattern_switch || pattern_switch == 0) {
           // Layer 0: predict from LAST and ARF, update LAST.
           frame_flags =
-              VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+              AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
         } else {
           // Layer 0: predict from GF and ARF, update GF.
-          frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
-                        VP8_EFLAG_NO_UPD_ARF;
+          frame_flags = AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_UPD_LAST |
+                        AOM_EFLAG_NO_UPD_ARF;
         }
       } else {
         if (frame_num < pattern_switch || pattern_switch == 0) {
           // Layer 1: predict from L, GF, and ARF, update GF.
-          frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+          frame_flags = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST;
         } else {
           // Layer 1: predict from GF and ARF, update GF.
-          frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
-                        VP8_EFLAG_NO_UPD_ARF;
+          frame_flags = AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_UPD_LAST |
+                        AOM_EFLAG_NO_UPD_ARF;
         }
       }
     }
@@ -93,7 +93,7 @@
   virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     frame_flags_ &=
-        ~(VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
+        ~(AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF);
     // For temporal layer case.
     if (cfg_.ts_number_layers > 1) {
       frame_flags_ =
@@ -111,8 +111,8 @@
           if (droppable_frames_[i] == video->frame()) {
             std::cout << "Encoding droppable frame: " << droppable_frames_[i]
                       << "\n";
-            frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-                             VP8_EFLAG_NO_UPD_ARF);
+            frame_flags_ |= (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+                             AOM_EFLAG_NO_UPD_ARF);
             return;
           }
         }
@@ -414,24 +414,24 @@
       if (frame_num % 2 == 0) {
         // Layer 0: predict from L and ARF, update L.
         frame_flags =
-            VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+            AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
       } else {
         // Layer 1: predict from L, G and ARF, and update G.
-        frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
-                      VP8_EFLAG_NO_UPD_ENTROPY;
+        frame_flags = AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST |
+                      AOM_EFLAG_NO_UPD_ENTROPY;
       }
     } else if (num_temp_layers == 3) {
       if (frame_num % 4 == 0) {
         // Layer 0: predict from L, update L.
-        frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
-                      VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
+        frame_flags = AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF |
+                      AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF;
       } else if ((frame_num - 2) % 4 == 0) {
         // Layer 1: predict from L, G,  update G.
         frame_flags =
-            VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
+            AOM_EFLAG_NO_UPD_ARF | AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_REF_ARF;
       } else if ((frame_num - 1) % 2 == 0) {
         // Layer 2: predict from L, G, ARF; update ARG.
-        frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
+        frame_flags = AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_LAST;
       }
     }
     return frame_flags;
@@ -463,8 +463,8 @@
       int layer_id = SetLayerId(video->frame(), cfg_.ts_number_layers);
       int frame_flags = SetFrameFlags(video->frame(), cfg_.ts_number_layers);
       if (video->frame() > 0) {
-        encoder->Control(VP8E_SET_TEMPORAL_LAYER_ID, layer_id);
-        encoder->Control(VP8E_SET_FRAME_FLAGS, frame_flags);
+        encoder->Control(AOME_SET_TEMPORAL_LAYER_ID, layer_id);
+        encoder->Control(AOME_SET_FRAME_FLAGS, frame_flags);
       }
       const aom_rational_t tb = video->timebase();
       timebase_ = static_cast<double>(tb.num) / tb.den;

diff --git a/test/ethread_test.cc b/test/ethread_test.cc
index cfb45e9..3282def 100644
--- a/test/ethread_test.cc
+++ b/test/ethread_test.cc

@@ -62,14 +62,14 @@
     if (!encoder_initialized_) {
       // Encode 4 column tiles.
       encoder->Control(VP9E_SET_TILE_COLUMNS, tiles_);
-      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
       if (encoding_mode_ != ::libaom_test::kRealTime) {
-        encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-        encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-        encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-        encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+        encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+        encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+        encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+        encoder->Control(AOME_SET_ARNR_TYPE, 3);
       } else {
-        encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 0);
+        encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
         encoder->Control(VP9E_SET_AQ_MODE, 3);
       }
       encoder_initialized_ = true;

diff --git a/test/frame_size_tests.cc b/test/frame_size_tests.cc
index 84ad4d2..63b839c 100644
--- a/test/frame_size_tests.cc
+++ b/test/frame_size_tests.cc

@@ -35,11 +35,11 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_CPUUSED, 7);
-      encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-      encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
-      encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
-      encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+      encoder->Control(AOME_SET_CPUUSED, 7);
+      encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+      encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+      encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+      encoder->Control(AOME_SET_ARNR_TYPE, 3);
     }
   }
 

diff --git a/test/resize_test.cc b/test/resize_test.cc
index 2dc2a60..b44055e 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc

@@ -191,23 +191,23 @@
     if (change_config_) {
       int new_q = 60;
       if (video->frame() == 0) {
-        struct aom_scaling_mode mode = { VP8E_ONETWO, VP8E_ONETWO };
-        encoder->Control(VP8E_SET_SCALEMODE, &mode);
+        struct aom_scaling_mode mode = { AOME_ONETWO, AOME_ONETWO };
+        encoder->Control(AOME_SET_SCALEMODE, &mode);
       }
       if (video->frame() == 1) {
-        struct aom_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
-        encoder->Control(VP8E_SET_SCALEMODE, &mode);
+        struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
+        encoder->Control(AOME_SET_SCALEMODE, &mode);
         cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
         encoder->Config(&cfg_);
       }
     } else {
       if (video->frame() == kStepDownFrame) {
-        struct aom_scaling_mode mode = { VP8E_FOURFIVE, VP8E_THREEFIVE };
-        encoder->Control(VP8E_SET_SCALEMODE, &mode);
+        struct aom_scaling_mode mode = { AOME_FOURFIVE, AOME_THREEFIVE };
+        encoder->Control(AOME_SET_SCALEMODE, &mode);
       }
       if (video->frame() == kStepUpFrame) {
-        struct aom_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
-        encoder->Control(VP8E_SET_SCALEMODE, &mode);
+        struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
+        encoder->Control(AOME_SET_SCALEMODE, &mode);
       }
     }
   }
@@ -287,7 +287,7 @@
                                   libaom_test::Encoder *encoder) {
     if (video->frame() == 0) {
       encoder->Control(VP9E_SET_AQ_MODE, 3);
-      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+      encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
     }
 
     if (change_bitrate_ && video->frame() == 120) {

diff --git a/test/simple_decoder.sh b/test/simple_decoder.sh
index e28d594..32c7134 100755
--- a/test/simple_decoder.sh
+++ b/test/simple_decoder.sh

@@ -16,9 +16,9 @@
 . $(dirname $0)/tools_common.sh
 
 # Environment check: Make sure input is available:
-#   $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+#   $AOM_IVF_FILE and $VP9_IVF_FILE are required.
 simple_decoder_verify_environment() {
-  if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
+  if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
     echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH."
     return 1
   fi
@@ -45,7 +45,7 @@
 
 simple_decoder_vp8() {
   if [ "$(vp8_decode_available)" = "yes" ]; then
-    simple_decoder "${VP8_IVF_FILE}" vp8 || return 1
+    simple_decoder "${AOM_IVF_FILE}" vp8 || return 1
   fi
 }
 

diff --git a/test/superframe_test.cc b/test/superframe_test.cc
index f4e7cac..6473ad0 100644
--- a/test/superframe_test.cc
+++ b/test/superframe_test.cc

@@ -45,7 +45,7 @@
   virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
                                   libaom_test::Encoder *encoder) {
     if (video->frame() == 1) {
-      encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
+      encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
     }
   }
 

diff --git a/test/svc_test.cc b/test/svc_test.cc
index d2e6d95..c92dbc4 100644
--- a/test/svc_test.cc
+++ b/test/svc_test.cc

@@ -75,7 +75,7 @@
     const aom_codec_err_t res =
         aom_svc_init(&svc_, &codec_, aom_codec_vp9_cx(), &codec_enc_);
     EXPECT_EQ(AOM_CODEC_OK, res);
-    aom_codec_control(&codec_, VP8E_SET_CPUUSED, 4);  // Make the test faster
+    aom_codec_control(&codec_, AOME_SET_CPUUSED, 4);  // Make the test faster
     aom_codec_control(&codec_, VP9E_SET_TILE_COLUMNS, tile_columns_);
     aom_codec_control(&codec_, VP9E_SET_TILE_ROWS, tile_rows_);
     codec_initialized_ = true;

diff --git a/test/tools_common.sh b/test/tools_common.sh
index 9bc1811..01fcbb7 100755
--- a/test/tools_common.sh
+++ b/test/tools_common.sh

@@ -383,7 +383,7 @@
 fi
 
 # Variables shared by tests.
-VP8_IVF_FILE="${LIBAOM_TEST_DATA_PATH}/vp80-00-comprehensive-001.ivf"
+AOM_IVF_FILE="${LIBAOM_TEST_DATA_PATH}/vp80-00-comprehensive-001.ivf"
 VP9_IVF_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-09-subpixel-00.ivf"
 
 VP9_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-00-quantizer-00.webm"
@@ -404,7 +404,7 @@
   LIBAOM_BIN_PATH=${LIBAOM_BIN_PATH}
   LIBAOM_CONFIG_PATH=${LIBAOM_CONFIG_PATH}
   LIBAOM_TEST_DATA_PATH=${LIBAOM_TEST_DATA_PATH}
-  VP8_IVF_FILE=${VP8_IVF_FILE}
+  AOM_IVF_FILE=${AOM_IVF_FILE}
   VP9_IVF_FILE=${VP9_IVF_FILE}
   VP9_WEBM_FILE=${VP9_WEBM_FILE}
   AOM_TEST_EXE_SUFFIX=${AOM_TEST_EXE_SUFFIX}

diff --git a/third_party/libwebm/mkvmuxer.cpp b/third_party/libwebm/mkvmuxer.cpp
index bf19f04..f55fc98 100644
--- a/third_party/libwebm/mkvmuxer.cpp
+++ b/third_party/libwebm/mkvmuxer.cpp

@@ -1043,7 +1043,7 @@
 
 const char Tracks::kOpusCodecId[] = "A_OPUS";
 const char Tracks::kVorbisCodecId[] = "A_VORBIS";
-const char Tracks::kVp8CodecId[] = "V_VP8";
+const char Tracks::kVp8CodecId[] = "V_AOM";
 const char Tracks::kVp9CodecId[] = "V_VP9";
 const char Tracks::kAV1CodecId[] = "V_AV1";
 

diff --git a/third_party/libwebm/mkvmuxer.hpp b/third_party/libwebm/mkvmuxer.hpp
index 27e0a3d..3159bbe 100644
--- a/third_party/libwebm/mkvmuxer.hpp
+++ b/third_party/libwebm/mkvmuxer.hpp

@@ -1214,7 +1214,7 @@
   //   frame: frame object
   bool AddGenericFrame(const Frame* frame);
 
-  // Adds a VP8 video track to the segment. Returns the number of the track on
+  // Adds a AOM video track to the segment. Returns the number of the track on
   // success, 0 on error. |number| is the number to use for the video track.
   // |number| must be >= 0. If |number| == 0 then the muxer will decide on
   // the track number.

diff --git a/tools_common.h b/tools_common.h
index e7c16c4..9fd3069 100644
--- a/tools_common.h
+++ b/tools_common.h

@@ -61,7 +61,7 @@
 
 #define RAW_FRAME_HDR_SZ sizeof(uint32_t)
 
-#define VP8_FOURCC 0x30385056
+#define AOM_FOURCC 0x30385056
 #define VP9_FOURCC 0x30395056
 #define AV1_FOURCC 0x303a5056
 

diff --git a/webmdec.cc b/webmdec.cc
index 54fe081..af0be9e 100644
--- a/webmdec.cc
+++ b/webmdec.cc

@@ -99,8 +99,8 @@
     return 0;
   }
 
-  if (!strncmp(video_track->GetCodecId(), "V_VP8", 5)) {
-    aom_ctx->fourcc = VP8_FOURCC;
+  if (!strncmp(video_track->GetCodecId(), "V_AOM", 5)) {
+    aom_ctx->fourcc = AOM_FOURCC;
   } else if (!strncmp(video_track->GetCodecId(), "V_VP9", 5)) {
     aom_ctx->fourcc = VP9_FOURCC;
   } else if (!strncmp(video_track->GetCodecId(), "V_AV1", 6)) {

diff --git a/webmenc.cc b/webmenc.cc
index a51a409..50fe1a6 100644
--- a/webmenc.cc
+++ b/webmenc.cc

@@ -48,7 +48,7 @@
   video_track->SetStereoMode(stereo_fmt);
   const char *codec_id;
   switch (fourcc) {
-    case VP8_FOURCC: codec_id = "V_VP8"; break;
+    case AOM_FOURCC: codec_id = "V_AOM"; break;
     case VP9_FOURCC: codec_id = "V_VP9"; break;
     case AV1_FOURCC: codec_id = "V_AV1"; break;
     default: codec_id = "V_AV1"; break;