Replace "VP8" with "AOM"

Note: Check AOMD_SET_DESCRIPTOR; there was a VPX & VP8 version
that when renamed become the same.

Change-Id: I022a71c0dfcd77948dda35ec754167e03bca616d

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!
 

aom/aom_encoder.h

@@ -798,7 +798,7 @@ aom_codec_err_t aom_codec_enc_init_multi_ver(
  *
  * \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.

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 @@ extern "C" {
 
 /*!\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 @@ typedef struct vp8_postproc_cfg {
 
 /*!\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 @@ typedef struct vp9_ref_frame {
 /*!\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 @@ AOM_CTRL_USE_TYPE(VP9_GET_REFERENCE, vp9_ref_frame_t *)
 }  // extern "C"
 #endif
 
-#endif  // AOM_VP8_H_
+#endif  // AOM_AOM_H_

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 @@ extern aom_codec_iface_t *aom_codec_av1_dx(void);
 /*!@} - 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 @@ enum vp8_dec_control_id {
   /** 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 @@ enum vp8_dec_control_id {
    */
   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 struct aom_decrypt_init {
 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 @@ AOM_CTRL_USE_TYPE(VP9_INVERT_TILE_DECODE_ORDER, int)
 }  // extern "C"
 #endif
 
-#endif  // AOM_VP8DX_H_
+#endif  // AOM_AOMDX_H_

aom_scale/yv12config.h

@@ -21,7 +21,7 @@ extern "C" {
 #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

aomdec.c

@@ -753,8 +753,8 @@ static int main_loop(int argc, const char **argv_) {
     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;

aomenc.c

@@ -450,12 +450,12 @@ static const arg_def_t *av1_args[] = {
   &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 @@ static void update_quantizer_histogram(struct stream_state *stream) {
   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]++;
   }

av1/av1_cx_iface.c

@@ -117,9 +117,9 @@ struct aom_codec_alg_priv {
 
 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 update_extra_cfg(aom_codec_alg_priv_t *ctx,
 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_noise_sensitivity(aom_codec_alg_priv_t *ctx,
 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_tile_rows(aom_codec_alg_priv_t *ctx,
 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_arnr_type(aom_codec_alg_priv_t *ctx,
 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 @@ static aom_codec_err_t ctrl_set_rc_max_intra_bitrate_pct(
     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 @@ static aom_codec_err_t ctrl_set_rc_max_inter_bitrate_pct(
     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 @@ static aom_codec_err_t encoder_encode(aom_codec_alg_priv_t *ctx,
   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_err_t ctrl_set_render_size(aom_codec_alg_priv_t *ctx,
 }
 
 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 @@ static aom_codec_ctrl_fn_map_t encoder_ctrl_maps[] = {
   { 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 },
 

av1/av1_dx_iface.c

@@ -294,7 +294,7 @@ static void init_buffer_callbacks(aom_codec_alg_priv_t *ctx) {
 }
 
 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_err_t ctrl_set_skip_loop_filter(aom_codec_alg_priv_t *ctx,
 }
 
 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 },

av1/encoder/encoder.c

@@ -4109,33 +4109,33 @@ int av1_get_quantizer(AV1_COMP *cpi) { return cpi->common.base_qindex; }
 
 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);
   }
 }

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 @@ static void set_roi_map(const aom_codec_enc_cfg_t *cfg,
   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 @@ static void set_active_map(const aom_codec_enc_cfg_t *cfg,
   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 @@ static void unset_active_map(const aom_codec_enc_cfg_t *cfg,
   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 @@ int main(int argc, char **argv) {
   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);

mainpage.dox

@@ -7,7 +7,7 @@
 
   \section main_intro Introduction