From 80edfa0132b162421ad3ec12dbe79de6faf3d162 Mon Sep 17 00:00:00 2001 From: Adrian Grange Date: Mon, 28 Mar 2016 10:04:30 -0700 Subject: [PATCH] Change "VP9" to "AV1" Change-Id: I6f40ab4725f59bee3d05e3989c1510dfd847b7f9 --- CHANGELOG | 34 +- aom/aom.h | 154 ++++ aom/aom_decoder.h | 4 +- aom/aom_encoder.h | 4 +- aom/aom_frame_buffer.h | 2 +- aom/aomcx.h | 844 ++++++++++++++++++ aom/aomdx.h | 165 ++++ aom/internal/aom_codec_internal.h | 2 +- aom/src/svc_encodeframe.c | 6 +- aom_dsp/arm/aom_convolve8_avg_neon_asm.asm | 4 +- aom_dsp/arm/aom_convolve8_neon_asm.asm | 4 +- aom_dsp/mips/inv_txfm_msa.h | 48 +- aomdec.c | 2 +- aomenc.c | 30 +- av1/av1_cx_iface.c | 74 +- av1/av1_dx_iface.c | 14 +- av1/encoder/cost.c | 2 +- av1/encoder/cost.h | 2 +- av1/encoder/encodeframe.c | 24 +- av1/encoder/encodemb.c | 4 +- av1/encoder/mcomp.c | 4 +- av1/encoder/rd.c | 2 +- av1/encoder/rd.h | 2 +- av1/encoder/rdopt.c | 2 +- av1/encoder/subexp.c | 2 +- examples/aom_temporal_svc_encoder.c | 18 +- examples/set_maps.c | 2 +- mainpage.dox | 2 +- test/active_map_refresh_test.cc | 2 +- test/aom_multi_resolution_encoder.sh | 75 ++ test/aomcx_set_ref.sh | 57 ++ test/aomdec.sh | 12 +- test/aq_segment_test.cc | 2 +- test/arf_freq_test.cc | 6 +- ..._encoder.sh => av1_spatial_svc_encoder.sh} | 14 +- test/convolve_test.cc | 20 +- test/datarate_test.cc | 40 +- test/decode_perf_test.cc | 40 +- test/decode_to_md5.sh | 6 +- test/decode_with_drops.sh | 12 +- test/denoiser_sse2_test.cc | 8 +- test/encode_api_test.cc | 6 - test/encode_perf_test.cc | 34 +- test/encode_test_driver.cc | 2 +- test/encoder_parms_get_to_decoder.cc | 22 +- test/end_to_end_test.cc | 4 +- test/ethread_test.cc | 4 +- test/frame_size_tests.cc | 12 +- test/idct8x8_test.cc | 2 +- test/intrapred_test.cc | 16 +- test/lossless_test.cc | 2 +- test/quantize_test.cc | 20 +- test/resize_test.cc | 2 +- test/simple_decoder.sh | 6 +- test/simple_encoder.sh | 2 +- test/subtract_test.cc | 12 +- test/svc_test.cc | 8 +- test/tile_independence_test.cc | 4 +- test/tools_common.sh | 12 +- test/twopass_encoder.sh | 2 +- third_party/libwebm/mkvmuxer.cpp | 2 +- tools_common.h | 4 +- webmdec.cc | 6 +- webmenc.cc | 2 - 64 files changed, 1609 insertions(+), 328 deletions(-) create mode 100644 aom/aom.h create mode 100644 aom/aomcx.h create mode 100644 aom/aomdx.h create mode 100755 test/aom_multi_resolution_encoder.sh create mode 100755 test/aomcx_set_ref.sh rename test/{vp9_spatial_svc_encoder.sh => av1_spatial_svc_encoder.sh} (85%) diff --git a/CHANGELOG b/CHANGELOG index ee174d414..47f6b36f6 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,49 +1,49 @@ 2015-11-09 v1.5.0 "Javan Whistling Duck" - This release improves upon the VP9 encoder and speeds up the encoding and + This release improves upon the AV1 encoder and speeds up the encoding and decoding processes. - Upgrading: This release is ABI incompatible with 1.4.0. It drops deprecated AOM - controls and adds a variety of VP9 controls for testing. + controls and adds a variety of AV1 controls for testing. - The aomenc utility now prefers VP9 by default. + The aomenc utility now prefers AV1 by default. - Enhancements: - Faster VP9 encoding and decoding - Smaller library size by combining functions used by AOM and VP9 + Faster AV1 encoding and decoding + Smaller library size by combining functions used by AOM and AV1 - Bug Fixes: A variety of fuzzing issues 2015-04-03 v1.4.0 "Indian Runner Duck" - This release includes significant improvements to the VP9 codec. + This release includes significant improvements to the AV1 codec. - Upgrading: This release is ABI incompatible with 1.3.0. It drops the compatibility layer, requiring AOM_IMG_FMT_* instead of IMG_FMT_*, and adds several codec - controls for VP9. + controls for AV1. - Enhancements: - Faster VP9 encoding and decoding - Multithreaded VP9 decoding (tile and frame-based) - Multithreaded VP9 encoding - on by default - YUV 4:2:2 and 4:4:4 support in VP9 - 10 and 12bit support in VP9 + Faster AV1 encoding and decoding + Multithreaded AV1 decoding (tile and frame-based) + Multithreaded AV1 encoding - on by default + YUV 4:2:2 and 4:4:4 support in AV1 + 10 and 12bit support in AV1 64bit ARM support by replacing ARM assembly with intrinsics - Bug Fixes: - Fixes a VP9 bitstream issue in Profile 1. This only affected non-YUV 4:2:0 + Fixes a AV1 bitstream issue in Profile 1. This only affected non-YUV 4:2:0 files. - Known Issues: Frame Parallel decoding fails for segmented and non-420 files. 2013-11-15 v1.3.0 "Forest" - This release introduces the VP9 codec in a backward-compatible way. + This release introduces the AV1 codec in a backward-compatible way. 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. + modification. However, some AOM options do not map to AV1 in the same manner. - The VP9 encoder in this release is not feature complete. Users interested in + The AV1 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 libaom mailing lists. @@ -78,7 +78,7 @@ Add encoding option --static-thresh - Speed: - Miscellaneous speed optimizations for AOM and VP9. + Miscellaneous speed optimizations for AOM and AV1. - Quality: In general, quality is consistent with the Eider release. diff --git a/aom/aom.h b/aom/aom.h new file mode 100644 index 000000000..7fc1effa1 --- /dev/null +++ b/aom/aom.h @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2016, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ + +/*!\defgroup vp8 AOM + * \ingroup codecs + * 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: + * - YUV 4:2:0 image format + * - Macro-block based coding (16x16 luma plus two 8x8 chroma) + * - 1/4 (1/8) pixel accuracy motion compensated prediction + * - 4x4 DCT transform + * - 128 level linear quantizer + * - In loop deblocking filter + * - Context-based entropy coding + * + * @{ + */ +/*!\file + * \brief Provides controls common to both the AOM encoder and decoder. + */ +#ifndef AOM_AOM_H_ +#define AOM_AOM_H_ + +#include "./aom_codec.h" +#include "./aom_image.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*!\brief Control functions + * + * The set of macros define the control functions of AOM interface + */ +enum vp8_com_control_id { + AOM_SET_REFERENCE = + 1, /**< pass in an external frame into decoder to be used as reference + 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 */ + 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 + * AOM_DECODER_CTRL_ID_START range next time we're ready to break the ABI. + */ + AV1_GET_REFERENCE = 128, /**< get a pointer to a reference frame */ + AOM_COMMON_CTRL_ID_MAX, + AOM_DECODER_CTRL_ID_START = 256 +}; + +/*!\brief post process flags + * + * The set of macros define AOM decoder post processing flags + */ +enum vp8_postproc_level { + 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 */ + 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 AOM_DEBLOCK and deblocking_level to 1. + */ + +typedef struct vp8_postproc_cfg { + int post_proc_flag; /**< the types of post processing to be done, should be + combination of "vp8_postproc_level" */ + int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */ + int noise_level; /**< the strength of additive noise, valid range [0, 16] */ +} vp8_postproc_cfg_t; + +/*!\brief reference frame type + * + * The set of macros define the type of AOM reference frames + */ +typedef enum aom_ref_frame_type { + AOM_LAST_FRAME = 1, + AOM_GOLD_FRAME = 2, + AOM_ALTR_FRAME = 4 +} aom_ref_frame_type_t; + +/*!\brief reference frame data struct + * + * Define the data struct to access vp8 reference frames. + */ +typedef struct aom_ref_frame { + aom_ref_frame_type_t frame_type; /**< which reference frame */ + aom_image_t img; /**< reference frame data in image format */ +} aom_ref_frame_t; + +/*!\brief AV1 specific reference frame data struct + * + * Define the data struct to access vp9 reference frames. + */ +typedef struct vp9_ref_frame { + int idx; /**< frame index to get (input) */ + aom_image_t img; /**< img structure to populate (output) */ +} vp9_ref_frame_t; + +/*!\cond */ +/*!\brief vp8 decoder control function parameter type + * + * defines the data type for each of AOM decoder control function requires + */ +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(AV1_GET_REFERENCE, vp9_ref_frame_t *) +#define AOM_CTRL_AV1_GET_REFERENCE + +/*!\endcond */ +/*! @} - end defgroup vp8 */ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AOM_AOM_H_ diff --git a/aom/aom_decoder.h b/aom/aom_decoder.h index 89844aaef..9d94a53ed 100644 --- a/aom/aom_decoder.h +++ b/aom/aom_decoder.h @@ -322,7 +322,7 @@ aom_codec_err_t aom_codec_register_put_slice_cb(aom_codec_ctx_t *ctx, * will result in an error code being returned, usually AOM_CODEC_ERROR. * * \note - * Currently this only works with VP9. + * Currently this only works with AV1. * @{ */ @@ -348,7 +348,7 @@ aom_codec_err_t aom_codec_register_put_slice_cb(aom_codec_ctx_t *ctx, * using external frame buffers. * * \note - * When decoding VP9, the application may be required to pass in at least + * When decoding AV1, the application may be required to pass in at least * #AOM_MAXIMUM_WORK_BUFFERS external frame * buffers. */ diff --git a/aom/aom_encoder.h b/aom/aom_encoder.h index 7da619f1b..1a4e588c1 100644 --- a/aom/aom_encoder.h +++ b/aom/aom_encoder.h @@ -702,7 +702,7 @@ typedef struct aom_codec_enc_cfg { /*!\brief Temporal layering mode indicating which temporal layering scheme to * use. * - * The value (refer to VP9E_TEMPORAL_LAYERING_MODE) specifies the + * The value (refer to AV1E_TEMPORAL_LAYERING_MODE) specifies the * temporal layering mode to use. * */ @@ -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 AOM and VP9. + * \param[in] reserved Must set to 0 for AOM and AV1. * * \retval #AOM_CODEC_OK * The configuration was populated. diff --git a/aom/aom_frame_buffer.h b/aom/aom_frame_buffer.h index 6c0cc93f4..c87cf749b 100644 --- a/aom/aom_frame_buffer.h +++ b/aom/aom_frame_buffer.h @@ -29,7 +29,7 @@ extern "C" { */ #define AOM_MAXIMUM_WORK_BUFFERS 8 -/*!\brief The maximum number of reference buffers that a VP9 encoder may use. +/*!\brief The maximum number of reference buffers that a AV1 encoder may use. */ #define AOM_MAXIMUM_REF_BUFFERS 8 diff --git a/aom/aomcx.h b/aom/aomcx.h new file mode 100644 index 000000000..02788090a --- /dev/null +++ b/aom/aomcx.h @@ -0,0 +1,844 @@ +/* + * Copyright (c) 2016, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ +#ifndef AOM_AOMCX_H_ +#define AOM_AOMCX_H_ + +/*!\defgroup vp8_encoder WebM AOM/AV1 Encoder + * \ingroup vp8 + * + * @{ + */ +#include "./aom.h" +#include "./aom_encoder.h" + +/*!\file + * \brief Provides definitions for using AOM or AV1 encoder algorithm within the + * aom Codec Interface. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/*!\name Algorithm interface for AV1 + * + * This interface provides the capability to encode raw AV1 streams. + * @{ + */ +extern aom_codec_iface_t aom_codec_av1_cx_algo; +extern aom_codec_iface_t *aom_codec_av1_cx(void); +/*!@} - end algorithm interface member group*/ + +/* + * Algorithm Flags + */ + +/*!\brief Don't reference the last frame + * + * When this flag is set, the encoder will not use the last frame as a + * predictor. When not set, the encoder will choose whether to use the + * last frame or not automatically. + */ +#define AOM_EFLAG_NO_REF_LAST (1 << 16) + +/*!\brief Don't reference the golden frame + * + * When this flag is set, the encoder will not use the golden frame as a + * predictor. When not set, the encoder will choose whether to use the + * golden frame or not automatically. + */ +#define AOM_EFLAG_NO_REF_GF (1 << 17) + +/*!\brief Don't reference the alternate reference frame + * + * When this flag is set, the encoder will not use the alt ref frame as a + * predictor. When not set, the encoder will choose whether to use the + * alt ref frame or not automatically. + */ +#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 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 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 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 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 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 AOM_EFLAG_NO_UPD_ENTROPY (1 << 20) + +/*!\brief VPx encoder control functions + * + * This set of macros define the control functions available for VPx + * encoder interface. + * + * \sa #aom_codec_control + */ +enum vp8e_enc_control_id { + /*!\brief Codec control function to pass an ROI map to encoder. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_ROI_MAP = 8, + + /*!\brief Codec control function to pass an Active map to encoder. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_ACTIVEMAP, + + /*!\brief Codec control function to set encoder scaling mode. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_SCALEMODE = 11, + + /*!\brief Codec control function to set encoder internal speed settings. + * + * Changes in this value influences, among others, the encoder's selection + * of motion estimation methods. Values greater than 0 will increase encoder + * speed at the expense of quality. + * + * \note Valid range for AOM: -16..16 + * \note Valid range for AV1: -8..8 + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_CPUUSED = 13, + + /*!\brief Codec control function to enable automatic set and use alf frames. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_ENABLEAUTOALTREF, + + /*!\brief control function to set noise sensitivity + * + * 0: off, 1: OnYOnly, 2: OnYUV, + * 3: OnYUVAggressive, 4: Adaptive + * + * Supported in codecs: AOM + */ + AOME_SET_NOISE_SENSITIVITY, + + /*!\brief Codec control function to set sharpness. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_SHARPNESS, + + /*!\brief Codec control function to set the threshold for MBs treated static. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_STATIC_THRESHOLD, + + /*!\brief Codec control function to set the number of token partitions. + * + * Supported in codecs: AOM + */ + 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: AOM, AV1 + */ + 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: AOM, AV1 + */ + AOME_GET_LAST_QUANTIZER_64, + + /*!\brief Codec control function to set the max no of frames to create arf. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_ARNR_MAXFRAMES, + + /*!\brief Codec control function to set the filter strength for the arf. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_ARNR_STRENGTH, + + /*!\deprecated control function to set the filter type to use for the arf. */ + AOME_SET_ARNR_TYPE, + + /*!\brief Codec control function to set visual tuning. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_TUNING, + + /*!\brief Codec control function to set constrained quality level. + * + * \attention For this value to be used aom_codec_enc_cfg_t::g_usage must be + * set to #AOM_CQ. + * \note Valid range: 0..63 + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_CQ_LEVEL, + + /*!\brief Codec control function to set Max data rate for Intra frames. + * + * This value controls additional clamping on the maximum size of a + * keyframe. It is expressed as a percentage of the average + * per-frame bitrate, with the special (and default) value 0 meaning + * unlimited, or no additional clamping beyond the codec's built-in + * algorithm. + * + * For example, to allocate no more than 4.5 frames worth of bitrate + * to a keyframe, set this to 450. + * + * Supported in codecs: AOM, AV1 + */ + AOME_SET_MAX_INTRA_BITRATE_PCT, + + /*!\brief Codec control function to set reference and update frame flags. + * + * Supported in codecs: AOM + */ + AOME_SET_FRAME_FLAGS, + + /*!\brief Codec control function to set max data rate for Inter frames. + * + * This value controls additional clamping on the maximum size of an + * inter frame. It is expressed as a percentage of the average + * per-frame bitrate, with the special (and default) value 0 meaning + * unlimited, or no additional clamping beyond the codec's built-in + * algorithm. + * + * For example, to allow no more than 4.5 frames worth of bitrate + * to an inter frame, set this to 450. + * + * Supported in codecs: AV1 + */ + AV1E_SET_MAX_INTER_BITRATE_PCT, + + /*!\brief Boost percentage for Golden Frame in CBR mode. + * + * This value controls the amount of boost given to Golden Frame in + * CBR mode. It is expressed as a percentage of the average + * per-frame bitrate, with the special (and default) value 0 meaning + * the feature is off, i.e., no golden frame boost in CBR mode and + * average bitrate target is used. + * + * For example, to allow 100% more bits, i.e, 2X, in a golden frame + * than average frame, set this to 100. + * + * Supported in codecs: AV1 + */ + AV1E_SET_GF_CBR_BOOST_PCT, + + /*!\brief Codec control function to set the temporal layer id. + * + * For temporal scalability: this control allows the application to set the + * layer id for each frame to be encoded. Note that this control must be set + * 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: AOM + */ + 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: AOM + */ + AOME_SET_SCREEN_CONTENT_MODE, + + /*!\brief Codec control function to set lossless encoding mode. + * + * AV1 can operate in lossless encoding mode, in which the bitstream + * produced will be able to decode and reconstruct a perfect copy of + * input source. This control function provides a mean to switch encoder + * into lossless coding mode(1) or normal coding mode(0) that may be lossy. + * 0 = lossy coding mode + * 1 = lossless coding mode + * + * By default, encoder operates in normal coding mode (maybe lossy). + * + * Supported in codecs: AV1 + */ + AV1E_SET_LOSSLESS, +#if CONFIG_AOM_QM + /*!\brief Codec control function to encode with quantisation matrices. + * + * AOM can operate with default quantisation matrices dependent on + * quantisation level and block type. + * 0 = do not use quantisation matrices + * 1 = use quantisation matrices + * + * By default, the encoder operates without quantisation matrices. + * + * Supported in codecs: AOM + */ + + AV1E_SET_ENABLE_QM, + + /*!\brief Codec control function to set the min quant matrix flatness. + * + * AOM can operate with different ranges of quantisation matrices. + * As quantisation levels increase, the matrices get flatter. This + * control sets the minimum level of flatness from which the matrices + * are determined. + * + * By default, the encoder sets this minimum at half the available + * range. + * + * Supported in codecs: AOM + */ + AV1E_SET_QM_MIN, + + /*!\brief Codec control function to set the max quant matrix flatness. + * + * AOM can operate with different ranges of quantisation matrices. + * As quantisation levels increase, the matrices get flatter. This + * control sets the maximum level of flatness possible. + * + * By default, the encoder sets this maximum at the top of the + * available range. + * + * Supported in codecs: AOM + */ + AV1E_SET_QM_MAX, +#endif + + /*!\brief Codec control function to set number of tile columns. + * + * In encoding and decoding, AV1 allows an input image frame be partitioned + * into separated vertical tile columns, which can be encoded or decoded + * independently. This enables easy implementation of parallel encoding and + * decoding. This control requests the encoder to use column tiles in + * encoding an input frame, with number of tile columns (in Log2 unit) as + * the parameter: + * 0 = 1 tile column + * 1 = 2 tile columns + * 2 = 4 tile columns + * ..... + * n = 2**n tile columns + * The requested tile columns will be capped by encoder based on image size + * limitation (The minimum width of a tile column is 256 pixel, the maximum + * is 4096). + * + * By default, the value is 0, i.e. one single column tile for entire image. + * + * Supported in codecs: AV1 + */ + AV1E_SET_TILE_COLUMNS, + + /*!\brief Codec control function to set number of tile rows. + * + * In encoding and decoding, AV1 allows an input image frame be partitioned + * into separated horizontal tile rows. Tile rows are encoded or decoded + * sequentially. Even though encoding/decoding of later tile rows depends on + * earlier ones, this allows the encoder to output data packets for tile rows + * prior to completely processing all tile rows in a frame, thereby reducing + * the latency in processing between input and output. The parameter + * for this control describes the number of tile rows, which has a valid + * range [0, 2]: + * 0 = 1 tile row + * 1 = 2 tile rows + * 2 = 4 tile rows + * + * By default, the value is 0, i.e. one single row tile for entire image. + * + * Supported in codecs: AV1 + */ + AV1E_SET_TILE_ROWS, + + /*!\brief Codec control function to enable frame parallel decoding feature. + * + * AV1 has a bitstream feature to reduce decoding dependency between frames + * by turning off backward update of probability context used in encoding + * and decoding. This allows staged parallel processing of more than one + * video frames in the decoder. This control function provides a mean to + * turn this feature on or off for bitstreams produced by encoder. + * + * By default, this feature is off. + * + * Supported in codecs: AV1 + */ + AV1E_SET_FRAME_PARALLEL_DECODING, + + /*!\brief Codec control function to set adaptive quantization mode. + * + * AV1 has a segment based feature that allows encoder to adaptively change + * quantization parameter for each segment within a frame to improve the + * subjective quality. This control makes encoder operate in one of the + * several AQ_modes supported. + * + * By default, encoder operates with AQ_Mode 0(adaptive quantization off). + * + * Supported in codecs: AV1 + */ + AV1E_SET_AQ_MODE, + + /*!\brief Codec control function to enable/disable periodic Q boost. + * + * One AV1 encoder speed feature is to enable quality boost by lowering + * frame level Q periodically. This control function provides a mean to + * turn on/off this feature. + * 0 = off + * 1 = on + * + * By default, the encoder is allowed to use this feature for appropriate + * encoding modes. + * + * Supported in codecs: AV1 + */ + AV1E_SET_FRAME_PERIODIC_BOOST, + + /*!\brief Codec control function to set noise sensitivity. + * + * 0: off, 1: On(YOnly) + * + * Supported in codecs: AV1 + */ + AV1E_SET_NOISE_SENSITIVITY, + + /*!\brief Codec control function to turn on/off SVC in encoder. + * \note Return value is AOM_CODEC_INVALID_PARAM if the encoder does not + * support SVC in its current encoding mode + * 0: off, 1: on + * + * Supported in codecs: AV1 + */ + AV1E_SET_SVC, + + /*!\brief Codec control function to set parameters for SVC. + * \note Parameters contain min_q, max_q, scaling factor for each of the + * SVC layers. + * + * Supported in codecs: AV1 + */ + AV1E_SET_SVC_PARAMETERS, + + /*!\brief Codec control function to set svc layer for spatial and temporal. + * \note Valid ranges: 0..#aom_codec_enc_cfg::ss_number_layers for spatial + * layer and 0..#aom_codec_enc_cfg::ts_number_layers for + * temporal layer. + * + * Supported in codecs: AV1 + */ + AV1E_SET_SVC_LAYER_ID, + + /*!\brief Codec control function to set content type. + * \note Valid parameter range: + * AOM_CONTENT_DEFAULT = Regular video content (Default) + * AOM_CONTENT_SCREEN = Screen capture content + * + * Supported in codecs: AV1 + */ + AV1E_SET_TUNE_CONTENT, + + /*!\brief Codec control function to get svc layer ID. + * \note The layer ID returned is for the data packet from the registered + * callback function. + * + * Supported in codecs: AV1 + */ + AV1E_GET_SVC_LAYER_ID, + + /*!\brief Codec control function to register callback to get per layer packet. + * \note Parameter for this control function is a structure with a callback + * function and a pointer to private data used by the callback. + * + * Supported in codecs: AV1 + */ + AV1E_REGISTER_CX_CALLBACK, + + /*!\brief Codec control function to set color space info. + * \note Valid ranges: 0..7, default is "UNKNOWN". + * 0 = UNKNOWN, + * 1 = BT_601 + * 2 = BT_709 + * 3 = SMPTE_170 + * 4 = SMPTE_240 + * 5 = BT_2020 + * 6 = RESERVED + * 7 = SRGB + * + * Supported in codecs: AV1 + */ + AV1E_SET_COLOR_SPACE, + + /*!\brief Codec control function to set temporal layering mode. + * \note Valid ranges: 0..3, default is "0" + * (AV1E_TEMPORAL_LAYERING_MODE_NOLAYERING). + * 0 = AV1E_TEMPORAL_LAYERING_MODE_NOLAYERING + * 1 = AV1E_TEMPORAL_LAYERING_MODE_BYPASS + * 2 = AV1E_TEMPORAL_LAYERING_MODE_0101 + * 3 = AV1E_TEMPORAL_LAYERING_MODE_0212 + * + * Supported in codecs: AV1 + */ + AV1E_SET_TEMPORAL_LAYERING_MODE, + + /*!\brief Codec control function to set minimum interval between GF/ARF frames + * + * By default the value is set as 4. + * + * Supported in codecs: AV1 + */ + AV1E_SET_MIN_GF_INTERVAL, + + /*!\brief Codec control function to set minimum interval between GF/ARF frames + * + * By default the value is set as 16. + * + * Supported in codecs: AV1 + */ + AV1E_SET_MAX_GF_INTERVAL, + + /*!\brief Codec control function to get an Active map back from the encoder. + * + * Supported in codecs: AV1 + */ + AV1E_GET_ACTIVEMAP, + + /*!\brief Codec control function to set color range bit. + * \note Valid ranges: 0..1, default is 0 + * 0 = Limited range (16..235 or HBD equivalent) + * 1 = Full range (0..255 or HBD equivalent) + * + * Supported in codecs: AV1 + */ + AV1E_SET_COLOR_RANGE, + + /*!\brief Codec control function to set the frame flags and buffer indices + * for spatial layers. The frame flags and buffer indices are set using the + * struct #aom_svc_ref_frame_config defined below. + * + * Supported in codecs: AV1 + */ + AV1E_SET_SVC_REF_FRAME_CONFIG, + + /*!\brief Codec control function to set intended rendering image size. + * + * By default, this is identical to the image size in pixels. + * + * Supported in codecs: AV1 + */ + AV1E_SET_RENDER_SIZE, +}; + +/*!\brief aom 1-D scaling mode + * + * This set of constants define 1-D aom scaling modes + */ +typedef enum aom_scaling_mode_1d { + AOME_NORMAL = 0, + AOME_FOURFIVE = 1, + AOME_THREEFIVE = 2, + AOME_ONETWO = 3 +} AOM_SCALING_MODE; + +/*!\brief Temporal layering mode enum for AV1 SVC. + * + * This set of macros define the different temporal layering modes. + * Supported codecs: AV1 (in SVC mode) + * + */ +typedef enum vp9e_temporal_layering_mode { + /*!\brief No temporal layering. + * Used when only spatial layering is used. + */ + AV1E_TEMPORAL_LAYERING_MODE_NOLAYERING = 0, + + /*!\brief Bypass mode. + * Used when application needs to control temporal layering. + * This will only work when the number of spatial layers equals 1. + */ + AV1E_TEMPORAL_LAYERING_MODE_BYPASS = 1, + + /*!\brief 0-1-0-1... temporal layering scheme with two temporal layers. + */ + AV1E_TEMPORAL_LAYERING_MODE_0101 = 2, + + /*!\brief 0-2-1-2... temporal layering scheme with three temporal layers. + */ + AV1E_TEMPORAL_LAYERING_MODE_0212 = 3 +} AV1E_TEMPORAL_LAYERING_MODE; + +/*!\brief aom region of interest map + * + * These defines the data structures for the region of interest map + * + */ + +typedef struct aom_roi_map { + /*! An id between 0 and 3 for each 16x16 region within a frame. */ + unsigned char *roi_map; + unsigned int rows; /**< Number of rows. */ + unsigned int cols; /**< Number of columns. */ + // TODO(paulwilkins): broken for AV1 which has 8 segments + // q and loop filter deltas for each segment + // (see MAX_MB_SEGMENTS) + int delta_q[4]; /**< Quantizer deltas. */ + int delta_lf[4]; /**< Loop filter deltas. */ + /*! Static breakout threshold for each segment. */ + unsigned int static_threshold[4]; +} aom_roi_map_t; + +/*!\brief aom active region map + * + * These defines the data structures for active region map + * + */ + +typedef struct aom_active_map { + unsigned char + *active_map; /**< specify an on (1) or off (0) each 16x16 region within a + frame */ + unsigned int rows; /**< number of rows */ + unsigned int cols; /**< number of cols */ +} aom_active_map_t; + +/*!\brief aom image scaling mode + * + * This defines the data structure for image scaling mode + * + */ +typedef struct aom_scaling_mode { + AOM_SCALING_MODE h_scaling_mode; /**< horizontal scaling mode */ + AOM_SCALING_MODE v_scaling_mode; /**< vertical scaling mode */ +} aom_scaling_mode_t; + +/*!\brief AOM token partition mode + * + * This defines AOM partitioning mode for compressed data, i.e., the number of + * sub-streams in the bitstream. Used for parallelized decoding. + * + */ + +typedef enum { + AOM_ONE_TOKENPARTITION = 0, + AOM_TWO_TOKENPARTITION = 1, + AOM_FOUR_TOKENPARTITION = 2, + AOM_EIGHT_TOKENPARTITION = 3 +} vp8e_token_partitions; + +/*!brief AV1 encoder content type */ +typedef enum { + AOM_CONTENT_DEFAULT, + AOM_CONTENT_SCREEN, + AOM_CONTENT_INVALID +} aom_tune_content; + +/*!\brief AOM model tuning parameters + * + * Changes the encoder to tune for certain types of input material. + * + */ +typedef enum { AOM_TUNE_PSNR, AOM_TUNE_SSIM } aom_tune_metric; + +/*!\brief vp9 svc layer parameters + * + * This defines the spatial and temporal layer id numbers for svc encoding. + * This is used with the #AV1E_SET_SVC_LAYER_ID control to set the spatial and + * temporal layer id for the current frame. + * + */ +typedef struct aom_svc_layer_id { + int spatial_layer_id; /**< Spatial layer id number. */ + int temporal_layer_id; /**< Temporal layer id number. */ +} aom_svc_layer_id_t; + +/*!\brief vp9 svc frame flag parameters. + * + * This defines the frame flags and buffer indices for each spatial layer for + * svc encoding. + * This is used with the #AV1E_SET_SVC_REF_FRAME_CONFIG control to set frame + * flags and buffer indices for each spatial layer for the current (super)frame. + * + */ +typedef struct aom_svc_ref_frame_config { + int frame_flags[AOM_TS_MAX_LAYERS]; /**< Frame flags. */ + int lst_fb_idx[AOM_TS_MAX_LAYERS]; /**< Last buffer index. */ + int gld_fb_idx[AOM_TS_MAX_LAYERS]; /**< Golden buffer index. */ + int alt_fb_idx[AOM_TS_MAX_LAYERS]; /**< Altref buffer index. */ +} aom_svc_ref_frame_config_t; + +/*!\cond */ +/*!\brief AOM encoder control function parameter type + * + * Defines the data types that AOME control functions take. Note that + * additional common controls are defined in aom.h + * + */ + +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(AV1E_SET_SVC, int) +#define AOM_CTRL_AV1E_SET_SVC +AOM_CTRL_USE_TYPE(AV1E_SET_SVC_PARAMETERS, void *) +#define AOM_CTRL_AV1E_SET_SVC_PARAMETERS +AOM_CTRL_USE_TYPE(AV1E_REGISTER_CX_CALLBACK, void *) +#define AOM_CTRL_AV1E_REGISTER_CX_CALLBACK +AOM_CTRL_USE_TYPE(AV1E_SET_SVC_LAYER_ID, aom_svc_layer_id_t *) +#define AOM_CTRL_AV1E_SET_SVC_LAYER_ID + +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(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(AV1E_SET_TILE_COLUMNS, int) +#define AOM_CTRL_AV1E_SET_TILE_COLUMNS +AOM_CTRL_USE_TYPE(AV1E_SET_TILE_ROWS, int) +#define AOM_CTRL_AV1E_SET_TILE_ROWS + +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(AV1E_GET_SVC_LAYER_ID, aom_svc_layer_id_t *) +#define AOM_CTRL_AV1E_GET_SVC_LAYER_ID + +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(AOME_SET_SCREEN_CONTENT_MODE, unsigned int) +#define AOM_CTRL_AOME_SET_SCREEN_CONTENT_MODE + +AOM_CTRL_USE_TYPE(AV1E_SET_GF_CBR_BOOST_PCT, unsigned int) +#define AOM_CTRL_AV1E_SET_GF_CBR_BOOST_PCT + +AOM_CTRL_USE_TYPE(AV1E_SET_LOSSLESS, unsigned int) +#define AOM_CTRL_AV1E_SET_LOSSLESS + +#if CONFIG_AOM_QM +AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_QM, unsigned int) +#define AOM_CTRL_AV1E_SET_ENABLE_QM + +AOM_CTRL_USE_TYPE(AV1E_SET_QM_MIN, unsigned int) +#define AOM_CTRL_AV1E_SET_QM_MIN + +AOM_CTRL_USE_TYPE(AV1E_SET_QM_MAX, unsigned int) +#define AOM_CTRL_AV1E_SET_QM_MAX +#endif + +AOM_CTRL_USE_TYPE(AV1E_SET_FRAME_PARALLEL_DECODING, unsigned int) +#define AOM_CTRL_AV1E_SET_FRAME_PARALLEL_DECODING + +AOM_CTRL_USE_TYPE(AV1E_SET_AQ_MODE, unsigned int) +#define AOM_CTRL_AV1E_SET_AQ_MODE + +AOM_CTRL_USE_TYPE(AV1E_SET_FRAME_PERIODIC_BOOST, unsigned int) +#define AOM_CTRL_AV1E_SET_FRAME_PERIODIC_BOOST + +AOM_CTRL_USE_TYPE(AV1E_SET_NOISE_SENSITIVITY, unsigned int) +#define AOM_CTRL_AV1E_SET_NOISE_SENSITIVITY + +AOM_CTRL_USE_TYPE(AV1E_SET_TUNE_CONTENT, int) /* aom_tune_content */ +#define AOM_CTRL_AV1E_SET_TUNE_CONTENT + +AOM_CTRL_USE_TYPE(AV1E_SET_COLOR_SPACE, int) +#define AOM_CTRL_AV1E_SET_COLOR_SPACE + +AOM_CTRL_USE_TYPE(AV1E_SET_MIN_GF_INTERVAL, unsigned int) +#define AOM_CTRL_AV1E_SET_MIN_GF_INTERVAL + +AOM_CTRL_USE_TYPE(AV1E_SET_MAX_GF_INTERVAL, unsigned int) +#define AOM_CTRL_AV1E_SET_MAX_GF_INTERVAL + +AOM_CTRL_USE_TYPE(AV1E_GET_ACTIVEMAP, aom_active_map_t *) +#define AOM_CTRL_AV1E_GET_ACTIVEMAP + +AOM_CTRL_USE_TYPE(AV1E_SET_COLOR_RANGE, int) +#define AOM_CTRL_AV1E_SET_COLOR_RANGE + +AOM_CTRL_USE_TYPE(AV1E_SET_SVC_REF_FRAME_CONFIG, aom_svc_ref_frame_config_t *) +#define AOM_CTRL_AV1E_SET_SVC_REF_FRAME_CONFIG + +AOM_CTRL_USE_TYPE(AV1E_SET_RENDER_SIZE, int *) +#define AOM_CTRL_AV1E_SET_RENDER_SIZE + +/*!\endcond */ +/*! @} - end defgroup vp8_encoder */ +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AOM_AOMCX_H_ diff --git a/aom/aomdx.h b/aom/aomdx.h new file mode 100644 index 000000000..bdc505466 --- /dev/null +++ b/aom/aomdx.h @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2016, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ + +/*!\defgroup vp8_decoder WebM AOM/AV1 Decoder + * \ingroup vp8 + * + * @{ + */ +/*!\file + * \brief Provides definitions for using AOM or AV1 within the aom Decoder + * interface. + */ +#ifndef AOM_AOMDX_H_ +#define AOM_AOMDX_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Include controls common to both the encoder and decoder */ +#include "./aom.h" + +/*!\name Algorithm interface for AV1 + * + * This interface provides the capability to decode AV1 streams. + * @{ + */ +extern aom_codec_iface_t aom_codec_av1_dx_algo; +extern aom_codec_iface_t *aom_codec_av1_dx(void); +/*!@} - end algorithm interface member group*/ + +/*!\enum vp8_dec_control_id + * \brief AOM decoder control functions + * + * This set of macros define the control functions available for the AOM + * decoder interface. + * + * \sa #aom_codec_control + */ +enum vp8_dec_control_id { + /** control function to get info on which reference frames were updated + * by the last decode + */ + AOMD_GET_LAST_REF_UPDATES = AOM_DECODER_CTRL_ID_START, + + /** check if the indicated frame is corrupted */ + AOMD_GET_FRAME_CORRUPTED, + + /** control function to get info on which reference frames were used + * by the last decode + */ + 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, + // 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 + * specified in the wrapper or frame header (see AV1D_GET_DISPLAY_SIZE). */ + AV1D_GET_FRAME_SIZE, + + /** control function to get the current frame's intended display dimensions + * (as specified in the wrapper or frame header). This may be different to + * the decoded dimensions of this frame (see AV1D_GET_FRAME_SIZE). */ + AV1D_GET_DISPLAY_SIZE, + + /** control function to get the bit depth of the stream. */ + AV1D_GET_BIT_DEPTH, + + /** control function to set the byte alignment of the planes in the reference + * buffers. Valid values are power of 2, from 32 to 1024. A value of 0 sets + * legacy alignment. I.e. Y plane is aligned to 32 bytes, U plane directly + * follows Y plane, and V plane directly follows U plane. Default value is 0. + */ + AV1_SET_BYTE_ALIGNMENT, + + /** control function to invert the decoding order to from right to left. The + * function is used in a test to confirm the decoding independence of tile + * columns. The function may be used in application where this order + * of decoding is desired. + * + * TODO(yaowu): Rework the unit test that uses this control, and in a future + * release, this test-only control shall be removed. + */ + AV1_INVERT_TILE_DECODE_ORDER, + + /** control function to set the skip loop filter flag. Valid values are + * integers. The decoder will skip the loop filter when its value is set to + * nonzero. If the loop filter is skipped the decoder may accumulate decode + * artifacts. The default value is 0. + */ + AV1_SET_SKIP_LOOP_FILTER, + + AOM_DECODER_CTRL_ID_MAX +}; + +/** Decrypt n bytes of data from input -> output, using the decrypt_state + * passed in AOMD_SET_DECRYPTOR. + */ +typedef void (*aom_decrypt_cb)(void *decrypt_state, const unsigned char *input, + unsigned char *output, int count); + +/*!\brief Structure to hold decryption state + * + * Defines a structure to hold the decryption state and access function. + */ +typedef struct aom_decrypt_init { + /*! Decrypt callback. */ + aom_decrypt_cb decrypt_cb; + + /*! Decryption state. */ + void *decrypt_state; +} aom_decrypt_init; + +/*!\brief A deprecated alias for aom_decrypt_init. + */ +typedef aom_decrypt_init vp8_decrypt_init; + +/*!\cond */ +/*!\brief AOM decoder control function parameter type + * + * Defines the data types that AOMD control functions take. Note that + * additional common controls are defined in aom.h + * + */ + +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(AOMD_SET_DECRYPTOR, aom_decrypt_init *) +//#define AOM_CTRL_AOMD_SET_DECRYPTOR +AOM_CTRL_USE_TYPE(AV1D_GET_DISPLAY_SIZE, int *) +#define AOM_CTRL_AV1D_GET_DISPLAY_SIZE +AOM_CTRL_USE_TYPE(AV1D_GET_BIT_DEPTH, unsigned int *) +#define AOM_CTRL_AV1D_GET_BIT_DEPTH +AOM_CTRL_USE_TYPE(AV1D_GET_FRAME_SIZE, int *) +#define AOM_CTRL_AV1D_GET_FRAME_SIZE +AOM_CTRL_USE_TYPE(AV1_INVERT_TILE_DECODE_ORDER, int) +#define AOM_CTRL_AV1_INVERT_TILE_DECODE_ORDER + +/*!\endcond */ +/*! @} - end defgroup vp8_decoder */ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AOM_AOMDX_H_ diff --git a/aom/internal/aom_codec_internal.h b/aom/internal/aom_codec_internal.h index 456d20226..fc758b8b8 100644 --- a/aom/internal/aom_codec_internal.h +++ b/aom/internal/aom_codec_internal.h @@ -240,7 +240,7 @@ typedef aom_image_t *(*aom_codec_get_frame_fn_t)(aom_codec_alg_priv_t *ctx, * using external frame buffers. * * \note - * When decoding VP9, the application may be required to pass in at least + * When decoding AV1, the application may be required to pass in at least * #AOM_MAXIMUM_WORK_BUFFERS external frame * buffers. */ diff --git a/aom/src/svc_encodeframe.c b/aom/src/svc_encodeframe.c index f0d0bb881..c7f6b903b 100644 --- a/aom/src/svc_encodeframe.c +++ b/aom/src/svc_encodeframe.c @@ -11,7 +11,7 @@ /** * @file - * VP9 SVC encoding support via libaom + * AV1 SVC encoding support via libaom */ #include @@ -492,8 +492,8 @@ aom_codec_err_t aom_svc_init(SvcContext *svc_ctx, aom_codec_ctx_t *codec_ctx, return res; } if (svc_ctx->spatial_layers > 1 || svc_ctx->temporal_layers > 1) { - aom_codec_control(codec_ctx, VP9E_SET_SVC, 1); - aom_codec_control(codec_ctx, VP9E_SET_SVC_PARAMETERS, &si->svc_params); + aom_codec_control(codec_ctx, AV1E_SET_SVC, 1); + aom_codec_control(codec_ctx, AV1E_SET_SVC_PARAMETERS, &si->svc_params); } return AOM_CODEC_OK; } diff --git a/aom_dsp/arm/aom_convolve8_avg_neon_asm.asm b/aom_dsp/arm/aom_convolve8_avg_neon_asm.asm index fcf3d4ef8..a408d9d29 100644 --- a/aom_dsp/arm/aom_convolve8_avg_neon_asm.asm +++ b/aom_dsp/arm/aom_convolve8_avg_neon_asm.asm @@ -14,8 +14,8 @@ ; w%4 == 0 ; h%4 == 0 ; taps == 8 - ; VP9_FILTER_WEIGHT == 128 - ; VP9_FILTER_SHIFT == 7 + ; AV1_FILTER_WEIGHT == 128 + ; AV1_FILTER_SHIFT == 7 EXPORT |aom_convolve8_avg_horiz_neon| EXPORT |aom_convolve8_avg_vert_neon| diff --git a/aom_dsp/arm/aom_convolve8_neon_asm.asm b/aom_dsp/arm/aom_convolve8_neon_asm.asm index 315e5b5c8..800876f06 100644 --- a/aom_dsp/arm/aom_convolve8_neon_asm.asm +++ b/aom_dsp/arm/aom_convolve8_neon_asm.asm @@ -14,8 +14,8 @@ ; w%4 == 0 ; h%4 == 0 ; taps == 8 - ; VP9_FILTER_WEIGHT == 128 - ; VP9_FILTER_SHIFT == 7 + ; AV1_FILTER_WEIGHT == 128 + ; AV1_FILTER_SHIFT == 7 EXPORT |aom_convolve8_horiz_neon| EXPORT |aom_convolve8_vert_neon| diff --git a/aom_dsp/mips/inv_txfm_msa.h b/aom_dsp/mips/inv_txfm_msa.h index 0dd8445f0..4fbba1a23 100644 --- a/aom_dsp/mips/inv_txfm_msa.h +++ b/aom_dsp/mips/inv_txfm_msa.h @@ -16,7 +16,7 @@ #include "aom_dsp/mips/txfm_macros_msa.h" #include "aom_dsp/txfm_common.h" -#define VP9_ADST8(in0, in1, in2, in3, in4, in5, in6, in7, out0, out1, out2, \ +#define AV1_ADST8(in0, in1, in2, in3, in4, in5, in6, in7, out0, out1, out2, \ out3, out4, out5, out6, out7) \ { \ v8i16 cnst0_m, cnst1_m, cnst2_m, cnst3_m, cnst4_m; \ @@ -182,7 +182,7 @@ PCKEV_H2_SH(int2_m, int2_m, int3_m, int3_m, out2, out3); \ } -#define VP9_SET_CONST_PAIR(mask_h, idx1_h, idx2_h) \ +#define AV1_SET_CONST_PAIR(mask_h, idx1_h, idx2_h) \ ({ \ v8i16 c0_m, c1_m; \ \ @@ -193,7 +193,7 @@ }) /* multiply and add macro */ -#define VP9_MADD(inp0, inp1, inp2, inp3, cst0, cst1, cst2, cst3, out0, out1, \ +#define AV1_MADD(inp0, inp1, inp2, inp3, cst0, cst1, cst2, cst3, out0, out1, \ out2, out3) \ { \ v8i16 madd_s0_m, madd_s1_m, madd_s2_m, madd_s3_m; \ @@ -221,13 +221,13 @@ v8i16 mask_m = { cospi_28_64, cospi_4_64, cospi_20_64, cospi_12_64, \ cospi_16_64, -cospi_4_64, -cospi_20_64, -cospi_16_64 }; \ \ - k0_m = VP9_SET_CONST_PAIR(mask_m, 0, 5); \ - k1_m = VP9_SET_CONST_PAIR(mask_m, 1, 0); \ - k2_m = VP9_SET_CONST_PAIR(mask_m, 6, 3); \ - k3_m = VP9_SET_CONST_PAIR(mask_m, 3, 2); \ - VP9_MADD(in1, in7, in3, in5, k0_m, k1_m, k2_m, k3_m, in1, in7, in3, in5); \ + k0_m = AV1_SET_CONST_PAIR(mask_m, 0, 5); \ + k1_m = AV1_SET_CONST_PAIR(mask_m, 1, 0); \ + k2_m = AV1_SET_CONST_PAIR(mask_m, 6, 3); \ + k3_m = AV1_SET_CONST_PAIR(mask_m, 3, 2); \ + AV1_MADD(in1, in7, in3, in5, k0_m, k1_m, k2_m, k3_m, in1, in7, in3, in5); \ SUB2(in1, in3, in7, in5, res0_m, res1_m); \ - k0_m = VP9_SET_CONST_PAIR(mask_m, 4, 7); \ + k0_m = AV1_SET_CONST_PAIR(mask_m, 4, 7); \ k1_m = __msa_splati_h(mask_m, 4); \ \ ILVRL_H2_SH(res0_m, res1_m, res2_m, res3_m); \ @@ -239,13 +239,13 @@ tp7_m = in7 + in5; \ k2_m = AOM_SET_COSPI_PAIR(cospi_24_64, -cospi_8_64); \ k3_m = AOM_SET_COSPI_PAIR(cospi_8_64, cospi_24_64); \ - VP9_MADD(in0, in4, in2, in6, k1_m, k0_m, k2_m, k3_m, in0, in4, in2, in6); \ + AV1_MADD(in0, in4, in2, in6, k1_m, k0_m, k2_m, k3_m, in0, in4, in2, in6); \ BUTTERFLY_4(in0, in4, in2, in6, tp0_m, tp1_m, tp2_m, tp3_m); \ BUTTERFLY_8(tp0_m, tp1_m, tp2_m, tp3_m, tp4_m, tp5_m, tp6_m, tp7_m, out0, \ out1, out2, out3, out4, out5, out6, out7); \ } -#define VP9_IADST8x8_1D(in0, in1, in2, in3, in4, in5, in6, in7, out0, out1, \ +#define AV1_IADST8x8_1D(in0, in1, in2, in3, in4, in5, in6, in7, out0, out1, \ out2, out3, out4, out5, out6, out7) \ { \ v4i32 r0_m, r1_m, r2_m, r3_m, r4_m, r5_m, r6_m, r7_m; \ @@ -259,13 +259,13 @@ -cospi_24_64, cospi_8_64, cospi_16_64, -cospi_16_64, 0, 0, 0, 0 \ }; \ \ - k0_m = VP9_SET_CONST_PAIR(mask1_m, 0, 1); \ - k1_m = VP9_SET_CONST_PAIR(mask1_m, 1, 2); \ + k0_m = AV1_SET_CONST_PAIR(mask1_m, 0, 1); \ + k1_m = AV1_SET_CONST_PAIR(mask1_m, 1, 2); \ ILVRL_H2_SH(in1, in0, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, r0_m, \ r1_m, r2_m, r3_m); \ - k0_m = VP9_SET_CONST_PAIR(mask1_m, 6, 7); \ - k1_m = VP9_SET_CONST_PAIR(mask2_m, 0, 1); \ + k0_m = AV1_SET_CONST_PAIR(mask1_m, 6, 7); \ + k1_m = AV1_SET_CONST_PAIR(mask2_m, 0, 1); \ ILVRL_H2_SH(in5, in4, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, r4_m, \ r5_m, r6_m, r7_m); \ @@ -277,13 +277,13 @@ m3_m); \ SRARI_W4_SW(m0_m, m1_m, m2_m, m3_m, DCT_CONST_BITS); \ PCKEV_H2_SW(m1_m, m0_m, m3_m, m2_m, t0_m, t1_m); \ - k0_m = VP9_SET_CONST_PAIR(mask1_m, 3, 4); \ - k1_m = VP9_SET_CONST_PAIR(mask1_m, 4, 5); \ + k0_m = AV1_SET_CONST_PAIR(mask1_m, 3, 4); \ + k1_m = AV1_SET_CONST_PAIR(mask1_m, 4, 5); \ ILVRL_H2_SH(in3, in2, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, r0_m, \ r1_m, r2_m, r3_m); \ - k0_m = VP9_SET_CONST_PAIR(mask2_m, 2, 3); \ - k1_m = VP9_SET_CONST_PAIR(mask2_m, 3, 4); \ + k0_m = AV1_SET_CONST_PAIR(mask2_m, 2, 3); \ + k1_m = AV1_SET_CONST_PAIR(mask2_m, 3, 4); \ ILVRL_H2_SH(in7, in6, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, r4_m, \ r5_m, r6_m, r7_m); \ @@ -297,12 +297,12 @@ PCKEV_H2_SW(m1_m, m0_m, m3_m, m2_m, r2_m, r3_m); \ ILVRL_H2_SW(r3_m, r2_m, m2_m, m3_m); \ BUTTERFLY_4(res0_m, res1_m, res3_m, res2_m, out0, in7, in4, in3); \ - k0_m = VP9_SET_CONST_PAIR(mask2_m, 5, 6); \ - k1_m = VP9_SET_CONST_PAIR(mask2_m, 6, 7); \ + k0_m = AV1_SET_CONST_PAIR(mask2_m, 5, 6); \ + k1_m = AV1_SET_CONST_PAIR(mask2_m, 6, 7); \ ILVRL_H2_SH(t1_m, t0_m, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, r0_m, \ r1_m, r2_m, r3_m); \ - k1_m = VP9_SET_CONST_PAIR(mask3_m, 0, 1); \ + k1_m = AV1_SET_CONST_PAIR(mask3_m, 0, 1); \ DOTP_SH4_SW(m2_m, m3_m, m2_m, m3_m, k0_m, k0_m, k1_m, k1_m, r4_m, r5_m, \ r6_m, r7_m); \ ADD4(r0_m, r6_m, r1_m, r7_m, r2_m, r4_m, r3_m, r5_m, m0_m, m1_m, m2_m, \ @@ -313,8 +313,8 @@ m3_m); \ SRARI_W4_SW(m0_m, m1_m, m2_m, m3_m, DCT_CONST_BITS); \ PCKEV_H2_SH(m1_m, m0_m, m3_m, m2_m, in2, in5); \ - k0_m = VP9_SET_CONST_PAIR(mask3_m, 2, 2); \ - k1_m = VP9_SET_CONST_PAIR(mask3_m, 2, 3); \ + k0_m = AV1_SET_CONST_PAIR(mask3_m, 2, 2); \ + k1_m = AV1_SET_CONST_PAIR(mask3_m, 2, 3); \ ILVRL_H2_SH(in4, in3, in_s1, in_s0); \ DOTP_SH4_SW(in_s1, in_s0, in_s1, in_s0, k0_m, k0_m, k1_m, k1_m, m0_m, \ m1_m, m2_m, m3_m); \ diff --git a/aomdec.c b/aomdec.c index f7efa9671..6200130e7 100644 --- a/aomdec.c +++ b/aomdec.c @@ -777,7 +777,7 @@ static int main_loop(int argc, const char **argv_) { int render_height = aom_input_ctx.height; if (!render_width || !render_height) { int render_size[2]; - if (aom_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE, + if (aom_codec_control(&decoder, AV1D_GET_DISPLAY_SIZE, render_size)) { // As last resort use size of first frame as display size. render_width = img->d_w; diff --git a/aomenc.c b/aomenc.c index 22cba5aea..947ab7e4b 100644 --- a/aomenc.c +++ b/aomenc.c @@ -452,20 +452,20 @@ static const arg_def_t *av1_args[] = { static const int av1_arg_ctrl_map[] = { AOME_SET_CPUUSED, AOME_SET_ENABLEAUTOALTREF, AOME_SET_SHARPNESS, AOME_SET_STATIC_THRESHOLD, - VP9E_SET_TILE_COLUMNS, VP9E_SET_TILE_ROWS, + AV1E_SET_TILE_COLUMNS, AV1E_SET_TILE_ROWS, 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, + AV1E_SET_MAX_INTER_BITRATE_PCT, AV1E_SET_GF_CBR_BOOST_PCT, + AV1E_SET_LOSSLESS, #if CONFIG_AOM_QM - VP9E_SET_ENABLE_QM, VP9E_SET_QM_MIN, - VP9E_SET_QM_MAX, + AV1E_SET_ENABLE_QM, AV1E_SET_QM_MIN, + AV1E_SET_QM_MAX, #endif - VP9E_SET_FRAME_PARALLEL_DECODING, VP9E_SET_AQ_MODE, - VP9E_SET_FRAME_PERIODIC_BOOST, VP9E_SET_NOISE_SENSITIVITY, - VP9E_SET_TUNE_CONTENT, VP9E_SET_COLOR_SPACE, - VP9E_SET_MIN_GF_INTERVAL, VP9E_SET_MAX_GF_INTERVAL, + AV1E_SET_FRAME_PARALLEL_DECODING, AV1E_SET_AQ_MODE, + AV1E_SET_FRAME_PERIODIC_BOOST, AV1E_SET_NOISE_SENSITIVITY, + AV1E_SET_TUNE_CONTENT, AV1E_SET_COLOR_SPACE, + AV1E_SET_MIN_GF_INTERVAL, AV1E_SET_MAX_GF_INTERVAL, 0 }; /* clang-format on */ @@ -899,7 +899,7 @@ static void parse_global_config(struct VpxEncoderConfig *global, char **argv) { /* Validate global config */ if (global->passes == 0) { #if CONFIG_AV1_ENCODER - // Make default VP9 passes = 2 until there is a better quality 1-pass + // Make default AV1 passes = 2 until there is a better quality 1-pass // encoder if (global->codec != NULL && global->codec->name != NULL) global->passes = (strcmp(global->codec->name, "vp9") == 0 && @@ -1040,7 +1040,7 @@ static int parse_stream_params(struct VpxEncoderConfig *global, if (0) { #if CONFIG_AV1_ENCODER } else if (strcmp(global->codec->name, "av1") == 0) { - // TODO(jingning): Reuse VP9 specific encoder configuration parameters. + // TODO(jingning): Reuse AV1 specific encoder configuration parameters. // Consider to expand this set for AV1 encoder control. ctrl_args = av1_args; ctrl_args_map = av1_arg_ctrl_map; @@ -1717,9 +1717,9 @@ static void test_decode(struct stream_state *stream, ref_enc.idx = 0; ref_dec.idx = 0; - aom_codec_control(&stream->encoder, VP9_GET_REFERENCE, &ref_enc); + aom_codec_control(&stream->encoder, AV1_GET_REFERENCE, &ref_enc); enc_img = ref_enc.img; - aom_codec_control(&stream->decoder, VP9_GET_REFERENCE, &ref_dec); + aom_codec_control(&stream->decoder, AV1_GET_REFERENCE, &ref_dec); dec_img = ref_dec.img; #if CONFIG_AOM_HIGHBITDEPTH if ((enc_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) != @@ -1857,7 +1857,7 @@ int main(int argc, const char **argv_) { if (!input.filename) usage_exit(); /* Decide if other chroma subsamplings than 4:2:0 are supported */ - if (global.codec->fourcc == VP9_FOURCC || global.codec->fourcc == AV1_FOURCC) + if (global.codec->fourcc == AV1_FOURCC) input.only_i420 = 0; for (pass = global.pass ? global.pass - 1 : 0; pass < global.passes; pass++) { @@ -2118,7 +2118,7 @@ int main(int argc, const char **argv_) { } if (global.show_psnr) { - if (global.codec->fourcc == VP9_FOURCC) { + if (global.codec->fourcc == AV1_FOURCC) { FOREACH_STREAM( show_psnr(stream, (1 << stream->config.cfg.g_input_bit_depth) - 1)); } else { diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c index e9c469ba5..e21d2cbed 100644 --- a/av1/av1_cx_iface.c +++ b/av1/av1_cx_iface.c @@ -552,7 +552,7 @@ static aom_codec_err_t ctrl_set_enable_auto_alt_ref(aom_codec_alg_priv_t *ctx, static aom_codec_err_t ctrl_set_noise_sensitivity(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.noise_sensitivity = CAST(VP9E_SET_NOISE_SENSITIVITY, args); + extra_cfg.noise_sensitivity = CAST(AV1E_SET_NOISE_SENSITIVITY, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -573,14 +573,14 @@ static aom_codec_err_t ctrl_set_static_thresh(aom_codec_alg_priv_t *ctx, static aom_codec_err_t ctrl_set_tile_columns(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.tile_columns = CAST(VP9E_SET_TILE_COLUMNS, args); + extra_cfg.tile_columns = CAST(AV1E_SET_TILE_COLUMNS, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_tile_rows(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.tile_rows = CAST(VP9E_SET_TILE_ROWS, args); + extra_cfg.tile_rows = CAST(AV1E_SET_TILE_ROWS, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -638,14 +638,14 @@ static aom_codec_err_t ctrl_set_rc_max_inter_bitrate_pct( static aom_codec_err_t ctrl_set_rc_gf_cbr_boost_pct(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.gf_cbr_boost_pct = CAST(VP9E_SET_GF_CBR_BOOST_PCT, args); + extra_cfg.gf_cbr_boost_pct = CAST(AV1E_SET_GF_CBR_BOOST_PCT, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_lossless(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.lossless = CAST(VP9E_SET_LOSSLESS, args); + extra_cfg.lossless = CAST(AV1E_SET_LOSSLESS, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -653,21 +653,21 @@ static aom_codec_err_t ctrl_set_lossless(aom_codec_alg_priv_t *ctx, static aom_codec_err_t ctrl_set_enable_qm(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.enable_qm = CAST(VP9E_SET_ENABLE_QM, args); + extra_cfg.enable_qm = CAST(AV1E_SET_ENABLE_QM, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_qm_min(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.qm_min = CAST(VP9E_SET_QM_MIN, args); + extra_cfg.qm_min = CAST(AV1E_SET_QM_MIN, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_qm_max(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.qm_max = CAST(VP9E_SET_QM_MAX, args); + extra_cfg.qm_max = CAST(AV1E_SET_QM_MAX, args); return update_extra_cfg(ctx, &extra_cfg); } #endif @@ -676,35 +676,35 @@ static aom_codec_err_t ctrl_set_frame_parallel_decoding_mode( aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; extra_cfg.frame_parallel_decoding_mode = - CAST(VP9E_SET_FRAME_PARALLEL_DECODING, args); + CAST(AV1E_SET_FRAME_PARALLEL_DECODING, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_aq_mode(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.aq_mode = CAST(VP9E_SET_AQ_MODE, args); + extra_cfg.aq_mode = CAST(AV1E_SET_AQ_MODE, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_min_gf_interval(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.min_gf_interval = CAST(VP9E_SET_MIN_GF_INTERVAL, args); + extra_cfg.min_gf_interval = CAST(AV1E_SET_MIN_GF_INTERVAL, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_max_gf_interval(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.max_gf_interval = CAST(VP9E_SET_MAX_GF_INTERVAL, args); + extra_cfg.max_gf_interval = CAST(AV1E_SET_MAX_GF_INTERVAL, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_frame_periodic_boost(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.frame_periodic_boost = CAST(VP9E_SET_FRAME_PERIODIC_BOOST, args); + extra_cfg.frame_periodic_boost = CAST(AV1E_SET_FRAME_PERIODIC_BOOST, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -1217,21 +1217,21 @@ static aom_codec_err_t ctrl_register_cx_callback(aom_codec_alg_priv_t *ctx, static aom_codec_err_t ctrl_set_tune_content(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.content = CAST(VP9E_SET_TUNE_CONTENT, args); + extra_cfg.content = CAST(AV1E_SET_TUNE_CONTENT, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_color_space(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.color_space = CAST(VP9E_SET_COLOR_SPACE, args); + extra_cfg.color_space = CAST(AV1E_SET_COLOR_SPACE, args); return update_extra_cfg(ctx, &extra_cfg); } static aom_codec_err_t ctrl_set_color_range(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.color_range = CAST(VP9E_SET_COLOR_RANGE, args); + extra_cfg.color_range = CAST(AV1E_SET_COLOR_RANGE, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -1257,39 +1257,39 @@ static aom_codec_ctrl_fn_map_t encoder_ctrl_maps[] = { { 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 }, + { AV1E_SET_TILE_COLUMNS, ctrl_set_tile_columns }, + { AV1E_SET_TILE_ROWS, ctrl_set_tile_rows }, { 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 }, + { AV1E_SET_MAX_INTER_BITRATE_PCT, ctrl_set_rc_max_inter_bitrate_pct }, + { AV1E_SET_GF_CBR_BOOST_PCT, ctrl_set_rc_gf_cbr_boost_pct }, + { AV1E_SET_LOSSLESS, ctrl_set_lossless }, #if CONFIG_AOM_QM - { VP9E_SET_ENABLE_QM, ctrl_set_enable_qm }, - { VP9E_SET_QM_MIN, ctrl_set_qm_min }, - { VP9E_SET_QM_MAX, ctrl_set_qm_max }, + { AV1E_SET_ENABLE_QM, ctrl_set_enable_qm }, + { AV1E_SET_QM_MIN, ctrl_set_qm_min }, + { AV1E_SET_QM_MAX, ctrl_set_qm_max }, #endif - { VP9E_SET_FRAME_PARALLEL_DECODING, ctrl_set_frame_parallel_decoding_mode }, - { VP9E_SET_AQ_MODE, ctrl_set_aq_mode }, - { VP9E_SET_FRAME_PERIODIC_BOOST, ctrl_set_frame_periodic_boost }, - { VP9E_REGISTER_CX_CALLBACK, ctrl_register_cx_callback }, - { VP9E_SET_TUNE_CONTENT, ctrl_set_tune_content }, - { VP9E_SET_COLOR_SPACE, ctrl_set_color_space }, - { VP9E_SET_COLOR_RANGE, ctrl_set_color_range }, - { VP9E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity }, - { VP9E_SET_MIN_GF_INTERVAL, ctrl_set_min_gf_interval }, - { VP9E_SET_MAX_GF_INTERVAL, ctrl_set_max_gf_interval }, - { VP9E_SET_RENDER_SIZE, ctrl_set_render_size }, + { AV1E_SET_FRAME_PARALLEL_DECODING, ctrl_set_frame_parallel_decoding_mode }, + { AV1E_SET_AQ_MODE, ctrl_set_aq_mode }, + { AV1E_SET_FRAME_PERIODIC_BOOST, ctrl_set_frame_periodic_boost }, + { AV1E_REGISTER_CX_CALLBACK, ctrl_register_cx_callback }, + { AV1E_SET_TUNE_CONTENT, ctrl_set_tune_content }, + { AV1E_SET_COLOR_SPACE, ctrl_set_color_space }, + { AV1E_SET_COLOR_RANGE, ctrl_set_color_range }, + { AV1E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity }, + { AV1E_SET_MIN_GF_INTERVAL, ctrl_set_min_gf_interval }, + { AV1E_SET_MAX_GF_INTERVAL, ctrl_set_max_gf_interval }, + { AV1E_SET_RENDER_SIZE, ctrl_set_render_size }, // Getters { 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_GET_REFERENCE, ctrl_get_reference }, + { AV1E_GET_ACTIVEMAP, ctrl_get_active_map }, { -1, NULL }, }; diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c index bd20d734a..591101b74 100644 --- a/av1/av1_dx_iface.c +++ b/av1/av1_dx_iface.c @@ -1026,18 +1026,18 @@ static aom_codec_ctrl_fn_map_t decoder_ctrl_maps[] = { { 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 }, + { AV1_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 }, + { AV1_SET_BYTE_ALIGNMENT, ctrl_set_byte_alignment }, + { AV1_SET_SKIP_LOOP_FILTER, ctrl_set_skip_loop_filter }, // Getters { 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 }, - { VP9D_GET_FRAME_SIZE, ctrl_get_frame_size }, + { AV1_GET_REFERENCE, ctrl_get_reference }, + { AV1D_GET_DISPLAY_SIZE, ctrl_get_render_size }, + { AV1D_GET_BIT_DEPTH, ctrl_get_bit_depth }, + { AV1D_GET_FRAME_SIZE, ctrl_get_frame_size }, { -1, NULL }, }; diff --git a/av1/encoder/cost.c b/av1/encoder/cost.c index a84f7d399..9ba30f0e0 100644 --- a/av1/encoder/cost.c +++ b/av1/encoder/cost.c @@ -12,7 +12,7 @@ #include "av1/encoder/cost.h" -/* round(-log2(i/256.) * (1 << VP9_PROB_COST_SHIFT)) +/* round(-log2(i/256.) * (1 << AV1_PROB_COST_SHIFT)) Begins and ends with a bogus entry to satisfy use of prob=0 in the firstpass. https://code.google.com/p/webm/issues/detail?id=1089 */ const uint16_t av1_prob_cost[257] = { diff --git a/av1/encoder/cost.h b/av1/encoder/cost.h index 374f7d9ab..c130ba184 100644 --- a/av1/encoder/cost.h +++ b/av1/encoder/cost.h @@ -22,7 +22,7 @@ extern "C" { extern const uint16_t av1_prob_cost[257]; // The factor to scale from cost in bits to cost in av1_prob_cost units. -#define VP9_PROB_COST_SHIFT 9 +#define AV1_PROB_COST_SHIFT 9 #define av1_cost_zero(prob) (av1_prob_cost[prob]) diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c index 7116a8980..66e2cdad9 100644 --- a/av1/encoder/encodeframe.c +++ b/av1/encoder/encodeframe.c @@ -55,7 +55,7 @@ static void encode_superblock(AV1_COMP *cpi, ThreadData *td, TOKENEXTRA **t, // purposes of activity masking. // Eventually this should be replaced by custom no-reference routines, // which will be faster. -static const uint8_t VP9_VAR_OFFS[64] = { +static const uint8_t AV1_VAR_OFFS[64] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, @@ -64,7 +64,7 @@ static const uint8_t VP9_VAR_OFFS[64] = { }; #if CONFIG_AOM_HIGHBITDEPTH -static const uint16_t VP9_HIGH_VAR_OFFS_8[64] = { +static const uint16_t AV1_HIGH_VAR_OFFS_8[64] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, @@ -72,7 +72,7 @@ static const uint16_t VP9_HIGH_VAR_OFFS_8[64] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; -static const uint16_t VP9_HIGH_VAR_OFFS_10[64] = { +static const uint16_t AV1_HIGH_VAR_OFFS_10[64] = { 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, @@ -83,7 +83,7 @@ static const uint16_t VP9_HIGH_VAR_OFFS_10[64] = { 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4 }; -static const uint16_t VP9_HIGH_VAR_OFFS_12[64] = { +static const uint16_t AV1_HIGH_VAR_OFFS_12[64] = { 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, @@ -102,7 +102,7 @@ unsigned int av1_get_sby_perpixel_variance(AV1_COMP *cpi, BLOCK_SIZE bs) { unsigned int sse; const unsigned int var = - cpi->fn_ptr[bs].vf(ref->buf, ref->stride, VP9_VAR_OFFS, 0, &sse); + cpi->fn_ptr[bs].vf(ref->buf, ref->stride, AV1_VAR_OFFS, 0, &sse); return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]); } @@ -115,18 +115,18 @@ unsigned int av1_high_get_sby_perpixel_variance(AV1_COMP *cpi, case 10: var = cpi->fn_ptr[bs].vf(ref->buf, ref->stride, - CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_10), 0, &sse); + CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_10), 0, &sse); break; case 12: var = cpi->fn_ptr[bs].vf(ref->buf, ref->stride, - CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_12), 0, &sse); + CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_12), 0, &sse); break; case 8: default: var = cpi->fn_ptr[bs].vf(ref->buf, ref->stride, - CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_8), 0, &sse); + CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_8), 0, &sse); break; } return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]); @@ -729,15 +729,15 @@ static int choose_partitioning(AV1_COMP *cpi, const TileInfo *const tile, } } } else { - d = VP9_VAR_OFFS; + d = AV1_VAR_OFFS; dp = 0; #if CONFIG_AOM_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { switch (xd->bd) { - case 10: d = CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_10); break; - case 12: d = CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_12); break; + case 10: d = CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_10); break; + case 12: d = CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_12); break; case 8: - default: d = CONVERT_TO_BYTEPTR(VP9_HIGH_VAR_OFFS_8); break; + default: d = CONVERT_TO_BYTEPTR(AV1_HIGH_VAR_OFFS_8); break; } } #endif // CONFIG_AOM_HIGHBITDEPTH diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c index c2d4ae867..b56a7ac08 100644 --- a/av1/encoder/encodemb.c +++ b/av1/encoder/encodemb.c @@ -51,8 +51,8 @@ void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane) { } #define RDTRUNC(RM, DM, R, D) \ - (((1 << (VP9_PROB_COST_SHIFT - 1)) + (R) * (RM)) & \ - ((1 << VP9_PROB_COST_SHIFT) - 1)) + (((1 << (AV1_PROB_COST_SHIFT - 1)) + (R) * (RM)) & \ + ((1 << AV1_PROB_COST_SHIFT) - 1)) typedef struct av1_token_state { int rate; diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c index 7de043492..75cf0b21c 100644 --- a/av1/encoder/mcomp.c +++ b/av1/encoder/mcomp.c @@ -84,7 +84,7 @@ static int mv_err_cost(const MV *mv, const MV *ref, const int *mvjcost, // accuracy in either bit cost or error cost will cause it to overflow. return ROUND_POWER_OF_TWO( (unsigned)mv_cost(&diff, mvjcost, mvcost) * error_per_bit, - RDDIV_BITS + VP9_PROB_COST_SHIFT - RD_EPB_SHIFT + + RDDIV_BITS + AV1_PROB_COST_SHIFT - RD_EPB_SHIFT + PIXEL_TRANSFORM_ERROR_SCALE); } return 0; @@ -95,7 +95,7 @@ static int mvsad_err_cost(const MACROBLOCK *x, const MV *mv, const MV *ref, const MV diff = { mv->row - ref->row, mv->col - ref->col }; return ROUND_POWER_OF_TWO( (unsigned)mv_cost(&diff, x->nmvjointsadcost, x->nmvsadcost) * sad_per_bit, - VP9_PROB_COST_SHIFT); + AV1_PROB_COST_SHIFT); } void av1_init_dsmotion_compensation(search_site_config *cfg, int stride) { diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c index 4c698576b..a9a42505d 100644 --- a/av1/encoder/rd.c +++ b/av1/encoder/rd.c @@ -386,7 +386,7 @@ void av1_model_rd_from_var_lapndz(unsigned int var, unsigned int n_log2, (((uint64_t)qstep * qstep << (n_log2 + 10)) + (var >> 1)) / var; const int xsq_q10 = (int)AOMMIN(xsq_q10_64, MAX_XSQ_Q10); model_rd_norm(xsq_q10, &r_q10, &d_q10); - *rate = ROUND_POWER_OF_TWO(r_q10 << n_log2, 10 - VP9_PROB_COST_SHIFT); + *rate = ROUND_POWER_OF_TWO(r_q10 << n_log2, 10 - AV1_PROB_COST_SHIFT); *dist = (var * (int64_t)d_q10 + 512) >> 10; } } diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h index 3f1cc98b2..84aad04c3 100644 --- a/av1/encoder/rd.h +++ b/av1/encoder/rd.h @@ -28,7 +28,7 @@ extern "C" { #define RD_EPB_SHIFT 6 #define RDCOST(RM, DM, R, D) \ - (ROUND_POWER_OF_TWO(((int64_t)R) * (RM), VP9_PROB_COST_SHIFT) + (D << DM)) + (ROUND_POWER_OF_TWO(((int64_t)R) * (RM), AV1_PROB_COST_SHIFT) + (D << DM)) #define QIDX_SKIP_THRESH 115 #define MV_COST_WEIGHT 108 diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c index 903b07604..d49464a98 100644 --- a/av1/encoder/rdopt.c +++ b/av1/encoder/rdopt.c @@ -243,7 +243,7 @@ static void model_rd_for_sb(AV1_COMP *cpi, BLOCK_SIZE bsize, MACROBLOCK *x, int quantizer = (pd->dequant[1] >> dequant_shift); if (quantizer < 120) - rate = (square_error * (280 - quantizer)) >> (16 - VP9_PROB_COST_SHIFT); + rate = (square_error * (280 - quantizer)) >> (16 - AV1_PROB_COST_SHIFT); else rate = 0; dist = (square_error * quantizer) >> 8; diff --git a/av1/encoder/subexp.c b/av1/encoder/subexp.c index a89ebcaff..863536d83 100644 --- a/av1/encoder/subexp.c +++ b/av1/encoder/subexp.c @@ -85,7 +85,7 @@ static int remap_prob(int v, int m) { static int prob_diff_update_cost(aom_prob newp, aom_prob oldp) { int delp = remap_prob(newp, oldp); - return update_bits[delp] << VP9_PROB_COST_SHIFT; + return update_bits[delp] << AV1_PROB_COST_SHIFT; } static void encode_uniform(aom_writer *w, int v) { diff --git a/examples/aom_temporal_svc_encoder.c b/examples/aom_temporal_svc_encoder.c index 94fa6f679..dfe7de012 100644 --- a/examples/aom_temporal_svc_encoder.c +++ b/examples/aom_temporal_svc_encoder.c @@ -630,7 +630,7 @@ int main(int argc, char **argv) { // Disable automatic keyframe placement. cfg.kf_min_dist = cfg.kf_max_dist = 3000; - cfg.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; + cfg.temporal_layering_mode = AV1E_TEMPORAL_LAYERING_MODE_BYPASS; set_temporal_layer_pattern(layering_mode, &cfg, layer_flags, &flag_periodicity); @@ -683,13 +683,13 @@ int main(int argc, char **argv) { } else if (strncmp(encoder->name, "vp9", 3) == 0) { aom_svc_extra_cfg_t svc_params; 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, AV1E_SET_AQ_MODE, 3); + aom_codec_control(&codec, AV1E_SET_FRAME_PERIODIC_BOOST, 0); + aom_codec_control(&codec, AV1E_SET_NOISE_SENSITIVITY, 0); 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)) + aom_codec_control(&codec, AV1E_SET_TUNE_CONTENT, 0); + aom_codec_control(&codec, AV1E_SET_TILE_COLUMNS, (cfg.g_threads >> 1)); + if (aom_codec_control(&codec, AV1E_SET_SVC, layering_mode > 0 ? 1 : 0)) die_codec(&codec, "Failed to set SVC"); for (i = 0; i < cfg.ts_number_layers; ++i) { svc_params.max_quantizers[i] = cfg.rc_max_quantizer; @@ -697,7 +697,7 @@ int main(int argc, char **argv) { } svc_params.scaling_factor_num[0] = cfg.g_h; svc_params.scaling_factor_den[0] = cfg.g_h; - aom_codec_control(&codec, VP9E_SET_SVC_PARAMETERS, &svc_params); + aom_codec_control(&codec, AV1E_SET_SVC_PARAMETERS, &svc_params); } if (strncmp(encoder->name, "vp8", 3) == 0) { aom_codec_control(&codec, AOME_SET_SCREEN_CONTENT_MODE, 0); @@ -724,7 +724,7 @@ int main(int argc, char **argv) { layer_id.temporal_layer_id = cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity]; if (strncmp(encoder->name, "vp9", 3) == 0) { - aom_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id); + aom_codec_control(&codec, AV1E_SET_SVC_LAYER_ID, &layer_id); } else if (strncmp(encoder->name, "vp8", 3) == 0) { aom_codec_control(&codec, AOME_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id); diff --git a/examples/set_maps.c b/examples/set_maps.c index d8f1496fb..425570510 100644 --- a/examples/set_maps.c +++ b/examples/set_maps.c @@ -216,7 +216,7 @@ int main(int argc, char **argv) { while (aom_img_read(&raw, infile)) { ++frame_count; - if (frame_count == 22 && encoder->fourcc == AOM_FOURCC) { + if (frame_count == 22 && encoder->fourcc == AV1_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 59b681064..30bb6de13 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 AOM and VP9 video codecs, high quality, royalty free, + applications with the AOM and AV1 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 d660076a0..1d7eb7de4 100644 --- a/test/active_map_refresh_test.cc +++ b/test/active_map_refresh_test.cc @@ -75,7 +75,7 @@ class ActiveMapRefreshTest static_cast(video); if (video->frame() == 1) { encoder->Control(AOME_SET_CPUUSED, cpu_used_); - encoder->Control(VP9E_SET_AQ_MODE, kAqModeCyclicRefresh); + encoder->Control(AV1E_SET_AQ_MODE, kAqModeCyclicRefresh); } else if (video->frame() >= 2 && video->img()) { aom_image_t *current = video->img(); aom_image_t *previous = y4m_holder_->img(); diff --git a/test/aom_multi_resolution_encoder.sh b/test/aom_multi_resolution_encoder.sh new file mode 100755 index 000000000..a64d6eada --- /dev/null +++ b/test/aom_multi_resolution_encoder.sh @@ -0,0 +1,75 @@ +#!/bin/sh +## +## Copyright (c) 2014 The WebM project authors. All Rights Reserved. +## +## Use of this source code is governed by a BSD-style license +## that can be found in the LICENSE file in the root of the source +## tree. An additional intellectual property rights grant can be found +## in the file PATENTS. All contributing project authors may +## be found in the AUTHORS file in the root of the source tree. +## +## This file tests the libaom vp8_multi_resolution_encoder example. To add new +## tests to this file, do the following: +## 1. Write a shell function (this is your test). +## 2. Add the function to vp8_mre_tests (on a new line). +## +. $(dirname $0)/tools_common.sh + +# Environment check: $YUV_RAW_INPUT is required. +vp8_multi_resolution_encoder_verify_environment() { + if [ "$(aom_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then + if [ ! -e "${YUV_RAW_INPUT}" ]; then + elog "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." + return 1 + fi + local readonly app="vp8_multi_resolution_encoder" + if [ -z "$(aom_tool_path "${app}")" ]; then + elog "${app} not found. It must exist in LIBAOM_BIN_PATH or its parent." + return 1 + fi + fi +} + +# Runs vp8_multi_resolution_encoder. Simply forwards all arguments to +# vp8_multi_resolution_encoder after building path to the executable. +vp8_mre() { + local readonly encoder="$(aom_tool_path vp8_multi_resolution_encoder)" + if [ ! -x "${encoder}" ]; then + elog "${encoder} does not exist or is not executable." + return 1 + fi + + eval "${AOM_TEST_PREFIX}" "${encoder}" "$@" ${devnull} +} + +vp8_multi_resolution_encoder_three_formats() { + local readonly output_files="${AOM_TEST_OUTPUT_DIR}/vp8_mre_0.ivf + ${AOM_TEST_OUTPUT_DIR}/vp8_mre_1.ivf + ${AOM_TEST_OUTPUT_DIR}/vp8_mre_2.ivf" + + if [ "$(aom_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then + if [ "$(vp8_encode_available)" = "yes" ]; then + # Param order: + # Input width + # Input height + # Input file path + # Output file names + # Output PSNR + vp8_mre "${YUV_RAW_INPUT_WIDTH}" \ + "${YUV_RAW_INPUT_HEIGHT}" \ + "${YUV_RAW_INPUT}" \ + ${output_files} \ + 0 + + for output_file in ${output_files}; do + if [ ! -e "${output_file}" ]; then + elog "Missing output file: ${output_file}" + return 1 + fi + done + fi + fi +} + +vp8_mre_tests="vp8_multi_resolution_encoder_three_formats" +run_tests vp8_multi_resolution_encoder_verify_environment "${vp8_mre_tests}" diff --git a/test/aomcx_set_ref.sh b/test/aomcx_set_ref.sh new file mode 100755 index 000000000..bcfed807d --- /dev/null +++ b/test/aomcx_set_ref.sh @@ -0,0 +1,57 @@ +#!/bin/sh +## +## Copyright (c) 2014 The WebM project authors. All Rights Reserved. +## +## Use of this source code is governed by a BSD-style license +## that can be found in the LICENSE file in the root of the source +## tree. An additional intellectual property rights grant can be found +## in the file PATENTS. All contributing project authors may +## be found in the AUTHORS file in the root of the source tree. +## +## This file tests the libaom vp8cx_set_ref example. To add new tests to this +## file, do the following: +## 1. Write a shell function (this is your test). +## 2. Add the function to vp8cx_set_ref_tests (on a new line). +## +. $(dirname $0)/tools_common.sh + +# Environment check: $YUV_RAW_INPUT is required. +vp8cx_set_ref_verify_environment() { + if [ ! -e "${YUV_RAW_INPUT}" ]; then + echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." + return 1 + fi +} + +# Runs vp8cx_set_ref and updates the reference frame before encoding frame 90. +# $1 is the codec name, which vp8cx_set_ref does not support at present: It's +# currently used only to name the output file. +# TODO(tomfinegan): Pass the codec param once the example is updated to support +# AV1. +aom_set_ref() { + local encoder="${LIBAOM_BIN_PATH}/vp8cx_set_ref${AOM_TEST_EXE_SUFFIX}" + local codec="$1" + local output_file="${AOM_TEST_OUTPUT_DIR}/vp8cx_set_ref_${codec}.ivf" + local ref_frame_num=90 + + if [ ! -x "${encoder}" ]; then + elog "${encoder} does not exist or is not executable." + return 1 + fi + + eval "${AOM_TEST_PREFIX}" "${encoder}" "${YUV_RAW_INPUT_WIDTH}" \ + "${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \ + "${ref_frame_num}" ${devnull} + + [ -e "${output_file}" ] || return 1 +} + +vp8cx_set_ref_vp8() { + if [ "$(vp8_encode_available)" = "yes" ]; then + aom_set_ref vp8 || return 1 + fi +} + +vp8cx_set_ref_tests="vp8cx_set_ref_vp8" + +run_tests vp8cx_set_ref_verify_environment "${vp8cx_set_ref_tests}" diff --git a/test/aomdec.sh b/test/aomdec.sh index fe50bfeef..0ad7311de 100755 --- a/test/aomdec.sh +++ b/test/aomdec.sh @@ -16,9 +16,9 @@ # Environment check: Make sure input is available. aomdec_verify_environment() { - if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_WEBM_FILE}" ] || \ - [ ! -e "${VP9_FPM_WEBM_FILE}" ] || \ - [ ! -e "${VP9_LT_50_FRAMES_WEBM_FILE}" ] ; then + if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${AV1_WEBM_FILE}" ] || \ + [ ! -e "${AV1_FPM_WEBM_FILE}" ] || \ + [ ! -e "${AV1_LT_50_FRAMES_WEBM_FILE}" ] ; then elog "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." return 1 fi @@ -76,7 +76,7 @@ aomdec_vp8_ivf_pipe_input() { aomdec_vp9_webm() { if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \ [ "$(webm_io_available)" = "yes" ]; then - aomdec "${VP9_WEBM_FILE}" --summary --noblit + aomdec "${AV1_WEBM_FILE}" --summary --noblit fi } @@ -84,7 +84,7 @@ aomdec_vp9_webm_frame_parallel() { if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \ [ "$(webm_io_available)" = "yes" ]; then for threads in 2 3 4 5 6 7 8; do - aomdec "${VP9_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \ + aomdec "${AV1_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \ --frame-parallel done fi @@ -98,7 +98,7 @@ aomdec_vp9_webm_less_than_50_frames() { local readonly decoder="$(aom_tool_path aomdec)" local readonly expected=10 local readonly num_frames=$(${AOM_TEST_PREFIX} "${decoder}" \ - "${VP9_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \ + "${AV1_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \ | awk '/^[0-9]+ decoded frames/ { print $1 }') if [ "$num_frames" -ne "$expected" ]; then elog "Output frames ($num_frames) != expected ($expected)" diff --git a/test/aq_segment_test.cc b/test/aq_segment_test.cc index a7ad9422d..3edf26b2b 100644 --- a/test/aq_segment_test.cc +++ b/test/aq_segment_test.cc @@ -33,7 +33,7 @@ class AqSegmentTest ::libaom_test::Encoder *encoder) { if (video->frame() == 1) { encoder->Control(AOME_SET_CPUUSED, set_cpu_used_); - encoder->Control(VP9E_SET_AQ_MODE, aq_mode_); + encoder->Control(AV1E_SET_AQ_MODE, aq_mode_); encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT, 100); } } diff --git a/test/arf_freq_test.cc b/test/arf_freq_test.cc index 47dbd6d7e..6c5ba4960 100644 --- a/test/arf_freq_test.cc +++ b/test/arf_freq_test.cc @@ -145,10 +145,10 @@ class ArfFreqTest virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video, ::libaom_test::Encoder *encoder) { if (video->frame() == 0) { - encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1); - encoder->Control(VP9E_SET_TILE_COLUMNS, 4); + encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1); + encoder->Control(AV1E_SET_TILE_COLUMNS, 4); encoder->Control(AOME_SET_CPUUSED, test_encode_param_.cpu_used); - encoder->Control(VP9E_SET_MIN_GF_INTERVAL, min_arf_requested_); + encoder->Control(AV1E_SET_MIN_GF_INTERVAL, min_arf_requested_); if (test_encode_param_.mode != ::libaom_test::kRealTime) { encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1); encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7); diff --git a/test/vp9_spatial_svc_encoder.sh b/test/av1_spatial_svc_encoder.sh similarity index 85% rename from test/vp9_spatial_svc_encoder.sh rename to test/av1_spatial_svc_encoder.sh index 6b9445854..eb9c30471 100755 --- a/test/vp9_spatial_svc_encoder.sh +++ b/test/av1_spatial_svc_encoder.sh @@ -8,7 +8,7 @@ ## in the file PATENTS. All contributing project authors may ## be found in the AUTHORS file in the root of the source tree. ## -## This file tests the libaom vp9_spatial_svc_encoder example. To add new +## This file tests the libaom av1_spatial_svc_encoder example. To add new ## tests to to this file, do the following: ## 1. Write a shell function (this is your test). ## 2. Add the function to vp9_spatial_svc_tests (on a new line). @@ -16,17 +16,17 @@ . $(dirname $0)/tools_common.sh # Environment check: $YUV_RAW_INPUT is required. -vp9_spatial_svc_encoder_verify_environment() { +av1_spatial_svc_encoder_verify_environment() { if [ ! -e "${YUV_RAW_INPUT}" ]; then echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." return 1 fi } -# Runs vp9_spatial_svc_encoder. $1 is the test name. -vp9_spatial_svc_encoder() { +# Runs av1_spatial_svc_encoder. $1 is the test name. +av1_spatial_svc_encoder() { local readonly \ - encoder="${LIBAOM_BIN_PATH}/vp9_spatial_svc_encoder${AOM_TEST_EXE_SUFFIX}" + encoder="${LIBAOM_BIN_PATH}/av1_spatial_svc_encoder${AOM_TEST_EXE_SUFFIX}" local readonly test_name="$1" local readonly \ output_file="${AOM_TEST_OUTPUT_DIR}/vp9_ssvc_encoder${test_name}.ivf" @@ -54,7 +54,7 @@ vp9_spatial_svc() { if [ "$(vp9_encode_available)" = "yes" ]; then local readonly test_name="vp9_spatial_svc" for layers in $(seq 1 ${vp9_ssvc_test_layers}); do - vp9_spatial_svc_encoder "${test_name}" -sl ${layers} + av1_spatial_svc_encoder "${test_name}" -sl ${layers} done fi } @@ -67,6 +67,6 @@ readonly vp9_spatial_svc_tests="DISABLED_vp9_spatial_svc_mode_i if [ "$(aom_config_option_enabled CONFIG_SPATIAL_SVC)" = "yes" ]; then run_tests \ - vp9_spatial_svc_encoder_verify_environment \ + av1_spatial_svc_encoder_verify_environment \ "${vp9_spatial_svc_tests}" fi diff --git a/test/convolve_test.cc b/test/convolve_test.cc index 3a735b225..0841f2c8a 100644 --- a/test/convolve_test.cc +++ b/test/convolve_test.cc @@ -68,8 +68,8 @@ struct ConvolveFunctions { typedef std::tr1::tuple ConvolveParam; // Reference 8-tap subpixel filter, slightly modified to fit into this test. -#define VP9_FILTER_WEIGHT 128 -#define VP9_FILTER_SHIFT 7 +#define AV1_FILTER_WEIGHT 128 +#define AV1_FILTER_SHIFT 7 uint8_t clip_pixel(int x) { return x < 0 ? 0 : x > 255 ? 255 : x; } void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride, @@ -106,10 +106,10 @@ void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride, (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) + (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) + (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) + - (VP9_FILTER_WEIGHT >> 1); // Rounding + (AV1_FILTER_WEIGHT >> 1); // Rounding // Normalize back to 0-255... - *output_ptr = clip_pixel(temp >> VP9_FILTER_SHIFT); + *output_ptr = clip_pixel(temp >> AV1_FILTER_SHIFT); ++src_ptr; output_ptr += intermediate_height; } @@ -127,10 +127,10 @@ void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride, (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) + (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) + (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) + - (VP9_FILTER_WEIGHT >> 1); // Rounding + (AV1_FILTER_WEIGHT >> 1); // Rounding // Normalize back to 0-255... - *dst_ptr++ = clip_pixel(temp >> VP9_FILTER_SHIFT); + *dst_ptr++ = clip_pixel(temp >> AV1_FILTER_SHIFT); src_ptr += intermediate_height; } src_ptr += intermediate_next_stride; @@ -203,10 +203,10 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr, (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) + (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) + (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) + - (VP9_FILTER_WEIGHT >> 1); // Rounding + (AV1_FILTER_WEIGHT >> 1); // Rounding // Normalize back to 0-255... - *output_ptr = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd); + *output_ptr = clip_pixel_highbd(temp >> AV1_FILTER_SHIFT, bd); ++src_ptr; output_ptr += intermediate_height; } @@ -227,10 +227,10 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr, (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) + (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) + (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) + - (VP9_FILTER_WEIGHT >> 1); // Rounding + (AV1_FILTER_WEIGHT >> 1); // Rounding // Normalize back to 0-255... - *dst_ptr++ = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd); + *dst_ptr++ = clip_pixel_highbd(temp >> AV1_FILTER_SHIFT, bd); src_ptr += intermediate_height; } src_ptr += intermediate_next_stride; diff --git a/test/datarate_test.cc b/test/datarate_test.cc index dba1bafe4..4b632974c 100644 --- a/test/datarate_test.cc +++ b/test/datarate_test.cc @@ -255,14 +255,14 @@ TEST_P(DatarateTestLarge, ChangingDropFrameThresh) { } } -class DatarateTestVP9Large +class DatarateTestAV1Large : public ::libaom_test::EncoderTest, public ::libaom_test::CodecTestWith2Params { public: - DatarateTestVP9Large() : EncoderTest(GET_PARAM(0)) {} + DatarateTestAV1Large() : EncoderTest(GET_PARAM(0)) {} protected: - virtual ~DatarateTestVP9Large() {} + virtual ~DatarateTestAV1Large() {} virtual void SetUp() { InitializeConfig(); @@ -364,18 +364,18 @@ class DatarateTestVP9Large } } - encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_); + encoder->Control(AV1E_SET_NOISE_SENSITIVITY, denoiser_on_); if (cfg_.ts_number_layers > 1) { if (video->frame() == 0) { - encoder->Control(VP9E_SET_SVC, 1); + encoder->Control(AV1E_SET_SVC, 1); } aom_svc_layer_id_t layer_id; layer_id.spatial_layer_id = 0; frame_flags_ = SetFrameFlags(video->frame(), cfg_.ts_number_layers); layer_id.temporal_layer_id = SetLayerId(video->frame(), cfg_.ts_number_layers); - encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id); + encoder->Control(AV1E_SET_SVC_LAYER_ID, &layer_id); } const aom_rational_t tb = video->timebase(); timebase_ = static_cast(tb.num) / tb.den; @@ -448,7 +448,7 @@ class DatarateTestVP9Large }; // Check basic rate targeting, -TEST_P(DatarateTestVP9Large, BasicRateTargeting) { +TEST_P(DatarateTestAV1Large, BasicRateTargeting) { cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 500; cfg_.rc_buf_sz = 1000; @@ -472,7 +472,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting) { } // Check basic rate targeting, -TEST_P(DatarateTestVP9Large, BasicRateTargeting444) { +TEST_P(DatarateTestAV1Large, BasicRateTargeting444) { ::libaom_test::Y4mVideoSource video("rush_hour_444.y4m", 0, 140); cfg_.g_profile = 1; @@ -504,7 +504,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting444) { // as the drop frame threshold is increased, and (2) that the total number of // frame drops does not decrease as we increase frame drop threshold. // Use a lower qp-max to force some frame drops. -TEST_P(DatarateTestVP9Large, ChangingDropFrameThresh) { +TEST_P(DatarateTestAV1Large, ChangingDropFrameThresh) { cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 500; cfg_.rc_buf_sz = 1000; @@ -546,7 +546,7 @@ TEST_P(DatarateTestVP9Large, ChangingDropFrameThresh) { // Check basic rate targeting for 2 temporal layers. #if 0 // AV1 does not support multiple layers yet -TEST_P(DatarateTestVP9Large, BasicRateTargeting2TemporalLayers) { +TEST_P(DatarateTestAV1Large, BasicRateTargeting2TemporalLayers) { cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 500; cfg_.rc_buf_sz = 1000; @@ -562,7 +562,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting2TemporalLayers) { cfg_.ts_rate_decimator[0] = 2; cfg_.ts_rate_decimator[1] = 1; - cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; + cfg_.temporal_layering_mode = AV1E_TEMPORAL_LAYERING_MODE_BYPASS; if (deadline_ == AOM_DL_REALTIME) cfg_.g_error_resilient = 1; @@ -588,7 +588,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting2TemporalLayers) { } // Check basic rate targeting for 3 temporal layers. -TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayers) { +TEST_P(DatarateTestAV1Large, BasicRateTargeting3TemporalLayers) { cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 500; cfg_.rc_buf_sz = 1000; @@ -605,7 +605,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayers) { cfg_.ts_rate_decimator[1] = 2; cfg_.ts_rate_decimator[2] = 1; - cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; + cfg_.temporal_layering_mode = AV1E_TEMPORAL_LAYERING_MODE_BYPASS; ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, 30, 1, 0, 200); @@ -635,7 +635,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayers) { // Check basic rate targeting for 3 temporal layers, with frame dropping. // Only for one (low) bitrate with lower max_quantizer, and somewhat higher // frame drop threshold, to force frame dropping. -TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayersFrameDropping) { +TEST_P(DatarateTestAV1Large, BasicRateTargeting3TemporalLayersFrameDropping) { cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 500; cfg_.rc_buf_sz = 1000; @@ -653,7 +653,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayersFrameDropping) { cfg_.ts_rate_decimator[1] = 2; cfg_.ts_rate_decimator[2] = 1; - cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; + cfg_.temporal_layering_mode = AV1E_TEMPORAL_LAYERING_MODE_BYPASS; ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, 30, 1, 0, 200); @@ -716,12 +716,12 @@ class DatarateOnePassCbrSvc svc_params_.scaling_factor_den[0] = 288; svc_params_.scaling_factor_num[1] = 288; svc_params_.scaling_factor_den[1] = 288; - encoder->Control(VP9E_SET_SVC, 1); - encoder->Control(VP9E_SET_SVC_PARAMETERS, &svc_params_); + encoder->Control(AV1E_SET_SVC, 1); + encoder->Control(AV1E_SET_SVC_PARAMETERS, &svc_params_); encoder->Control(AOME_SET_CPUUSED, speed_setting_); - encoder->Control(VP9E_SET_TILE_COLUMNS, 0); + encoder->Control(AV1E_SET_TILE_COLUMNS, 0); encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT, 300); - encoder->Control(VP9E_SET_TILE_COLUMNS, (cfg_.g_threads >> 1)); + encoder->Control(AV1E_SET_TILE_COLUMNS, (cfg_.g_threads >> 1)); } const aom_rational_t tb = video->timebase(); timebase_ = static_cast(tb.num) / tb.den; @@ -894,7 +894,7 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc4threads) { EXPECT_EQ(GetMismatchFrames(), (unsigned int)0); } -AV1_INSTANTIATE_TEST_CASE(DatarateTestVP9Large, +AV1_INSTANTIATE_TEST_CASE(DatarateTestAV1Large, ::testing::Values(::libaom_test::kOnePassGood, ::libaom_test::kRealTime), ::testing::Range(2, 7)); diff --git a/test/decode_perf_test.cc b/test/decode_perf_test.cc index f0517e66e..3e5d8908f 100644 --- a/test/decode_perf_test.cc +++ b/test/decode_perf_test.cc @@ -37,7 +37,7 @@ const char kNewEncodeOutputFile[] = "new_encode.ivf"; */ typedef std::tr1::tuple DecodePerfParam; -const DecodePerfParam kVP9DecodePerfVectors[] = { +const DecodePerfParam kAV1DecodePerfVectors[] = { make_tuple("vp90-2-bbb_426x240_tile_1x1_180kbps.webm", 1), make_tuple("vp90-2-bbb_640x360_tile_1x2_337kbps.webm", 2), make_tuple("vp90-2-bbb_854x480_tile_1x2_651kbps.webm", 2), @@ -81,7 +81,7 @@ TEST_P(DecodePerfTest, PerfTest) { aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t(); cfg.threads = threads; - libaom_test::VP9Decoder decoder(cfg, 0); + libaom_test::AV1Decoder decoder(cfg, 0); aom_usec_timer t; aom_usec_timer_start(&t); @@ -106,18 +106,18 @@ TEST_P(DecodePerfTest, PerfTest) { printf("}\n"); } -INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest, - ::testing::ValuesIn(kVP9DecodePerfVectors)); +INSTANTIATE_TEST_CASE_P(AV1, DecodePerfTest, + ::testing::ValuesIn(kAV1DecodePerfVectors)); -class VP9NewEncodeDecodePerfTest +class AV1NewEncodeDecodePerfTest : public ::libaom_test::EncoderTest, public ::libaom_test::CodecTestWithParam { protected: - VP9NewEncodeDecodePerfTest() + AV1NewEncodeDecodePerfTest() : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)), speed_(0), outfile_(0), out_frames_(0) {} - virtual ~VP9NewEncodeDecodePerfTest() {} + virtual ~AV1NewEncodeDecodePerfTest() {} virtual void SetUp() { InitializeConfig(); @@ -140,8 +140,8 @@ class VP9NewEncodeDecodePerfTest ::libaom_test::Encoder *encoder) { if (video->frame() == 1) { encoder->Control(AOME_SET_CPUUSED, speed_); - encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1); - encoder->Control(VP9E_SET_TILE_COLUMNS, 2); + encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1); + encoder->Control(AV1E_SET_TILE_COLUMNS, 2); } } @@ -155,7 +155,7 @@ class VP9NewEncodeDecodePerfTest virtual void EndPassHook() { if (outfile_ != NULL) { if (!fseek(outfile_, 0, SEEK_SET)) - ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_); + ivf_write_file_header(outfile_, &cfg_, AV1_FOURCC, out_frames_); fclose(outfile_); outfile_ = NULL; } @@ -166,7 +166,7 @@ class VP9NewEncodeDecodePerfTest // Write initial file header if first frame. if (pkt->data.frame.pts == 0) - ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_); + ivf_write_file_header(outfile_, &cfg_, AV1_FOURCC, out_frames_); // Write frame header and data. ivf_write_frame_header(outfile_, out_frames_, pkt->data.frame.sz); @@ -197,26 +197,26 @@ struct EncodePerfTestVideo { int frames; }; -const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = { +const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = { EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470), }; -TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) { +TEST_P(AV1NewEncodeDecodePerfTest, PerfTest) { SetUp(); // TODO(JBB): Make this work by going through the set of given files. const int i = 0; const aom_rational timebase = { 33333333, 1000000000 }; cfg_.g_timebase = timebase; - cfg_.rc_target_bitrate = kVP9EncodePerfTestVectors[i].bitrate; + cfg_.rc_target_bitrate = kAV1EncodePerfTestVectors[i].bitrate; init_flags_ = AOM_CODEC_USE_PSNR; - const char *video_name = kVP9EncodePerfTestVectors[i].name; + const char *video_name = kAV1EncodePerfTestVectors[i].name; libaom_test::I420VideoSource video( - video_name, kVP9EncodePerfTestVectors[i].width, - kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0, - kVP9EncodePerfTestVectors[i].frames); + video_name, kAV1EncodePerfTestVectors[i].width, + kAV1EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0, + kAV1EncodePerfTestVectors[i].frames); set_speed(2); ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); @@ -228,7 +228,7 @@ TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) { aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t(); cfg.threads = threads; - libaom_test::VP9Decoder decoder(cfg, 0); + libaom_test::AV1Decoder decoder(cfg, 0); aom_usec_timer t; aom_usec_timer_start(&t); @@ -255,6 +255,6 @@ TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) { printf("}\n"); } -AV1_INSTANTIATE_TEST_CASE(VP9NewEncodeDecodePerfTest, +AV1_INSTANTIATE_TEST_CASE(AV1NewEncodeDecodePerfTest, ::testing::Values(::libaom_test::kTwoPassGood)); } // namespace diff --git a/test/decode_to_md5.sh b/test/decode_to_md5.sh index 3007c51ae..4ad092aef 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: -# $AOM_IVF_FILE and $VP9_IVF_FILE are required. +# $AOM_IVF_FILE and $AV1_IVF_FILE are required. decode_to_md5_verify_environment() { - if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then + if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." return 1 fi @@ -63,7 +63,7 @@ decode_to_md5_vp9() { local expected_md5="2952c0eae93f3dadd1aa84c50d3fd6d2" if [ "$(vp9_decode_available)" = "yes" ]; then - decode_to_md5 "${VP9_IVF_FILE}" "vp9" "${expected_md5}" + decode_to_md5 "${AV1_IVF_FILE}" "vp9" "${expected_md5}" fi } diff --git a/test/decode_with_drops.sh b/test/decode_with_drops.sh index 9d3382571..edc129375 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: -# $AOM_IVF_FILE and $VP9_IVF_FILE are required. +# $AOM_IVF_FILE and $AV1_IVF_FILE are required. decode_with_drops_verify_environment() { - if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then + if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." return 1 fi @@ -59,17 +59,17 @@ decode_with_drops_vp8() { fi } -# Decodes $VP9_IVF_FILE while dropping frames, twice: once in sequence mode, +# Decodes $AV1_IVF_FILE while dropping frames, twice: once in sequence mode, # and once in pattern mode. -# Note: This test assumes that $VP9_IVF_FILE has exactly 20 frames, and could +# Note: This test assumes that $AV1_IVF_FILE has exactly 20 frames, and could # break if the file is modified. decode_with_drops_vp9() { if [ "$(vp9_decode_available)" = "yes" ]; then # Test sequence mode: Drop frames 2-28. - decode_with_drops "${VP9_IVF_FILE}" "vp9" "2-19" + decode_with_drops "${AV1_IVF_FILE}" "vp9" "2-19" # Test pattern mode: Drop 3 of every 4 frames. - decode_with_drops "${VP9_IVF_FILE}" "vp9" "3/4" + decode_with_drops "${AV1_IVF_FILE}" "vp9" "3/4" fi } diff --git a/test/denoiser_sse2_test.cc b/test/denoiser_sse2_test.cc index 88600094a..c9ed2be43 100644 --- a/test/denoiser_sse2_test.cc +++ b/test/denoiser_sse2_test.cc @@ -29,9 +29,9 @@ using libaom_test::ACMRandom; namespace { const int kNumPixels = 64 * 64; -class VP9DenoiserTest : public ::testing::TestWithParam { +class AV1DenoiserTest : public ::testing::TestWithParam { public: - virtual ~VP9DenoiserTest() {} + virtual ~AV1DenoiserTest() {} virtual void SetUp() { bs_ = GetParam(); } @@ -41,7 +41,7 @@ class VP9DenoiserTest : public ::testing::TestWithParam { BLOCK_SIZE bs_; }; -TEST_P(VP9DenoiserTest, BitexactCheck) { +TEST_P(AV1DenoiserTest, BitexactCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); const int count_test_block = 4000; @@ -90,7 +90,7 @@ TEST_P(VP9DenoiserTest, BitexactCheck) { } // Test for all block size. -INSTANTIATE_TEST_CASE_P(SSE2, VP9DenoiserTest, +INSTANTIATE_TEST_CASE_P(SSE2, AV1DenoiserTest, ::testing::Values(BLOCK_4X4, BLOCK_4X8, BLOCK_8X4, BLOCK_8X8, BLOCK_8X16, BLOCK_16X8, BLOCK_16X16, BLOCK_16X32, BLOCK_32X16, diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc index c67e62b5b..c45c7618f 100644 --- a/test/encode_api_test.cc +++ b/test/encode_api_test.cc @@ -20,12 +20,6 @@ namespace { TEST(EncodeAPI, InvalidParams) { static const aom_codec_iface_t *kCodecs[] = { -#if CONFIG_AOM_ENCODER - &aom_codec_vp8_cx_algo, -#endif -#if CONFIG_VP9_ENCODER - &aom_codec_vp9_cx_algo, -#endif #if CONFIG_AV1_ENCODER &aom_codec_av1_cx_algo, #endif diff --git a/test/encode_perf_test.cc b/test/encode_perf_test.cc index ba86c56ae..60a17042d 100644 --- a/test/encode_perf_test.cc +++ b/test/encode_perf_test.cc @@ -35,7 +35,7 @@ struct EncodePerfTestVideo { int frames; }; -const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = { +const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = { EncodePerfTestVideo("desktop_640_360_30.yuv", 640, 360, 200, 2484), EncodePerfTestVideo("kirland_640_480_30.yuv", 640, 480, 200, 300), EncodePerfTestVideo("macmarcomoving_640_480_30.yuv", 640, 480, 200, 987), @@ -53,15 +53,15 @@ const int kEncodePerfTestThreads[] = { 1, 2, 4 }; #define NELEMENTS(x) (sizeof((x)) / sizeof((x)[0])) -class VP9EncodePerfTest +class AV1EncodePerfTest : public ::libaom_test::EncoderTest, public ::libaom_test::CodecTestWithParam { protected: - VP9EncodePerfTest() + AV1EncodePerfTest() : EncoderTest(GET_PARAM(0)), min_psnr_(kMaxPsnr), nframes_(0), encoding_mode_(GET_PARAM(1)), speed_(0), threads_(1) {} - virtual ~VP9EncodePerfTest() {} + virtual ~AV1EncodePerfTest() {} virtual void SetUp() { InitializeConfig(); @@ -87,8 +87,8 @@ class VP9EncodePerfTest if (video->frame() == 0) { const int log2_tile_columns = 3; 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(AV1E_SET_TILE_COLUMNS, log2_tile_columns); + encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1); encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0); } } @@ -121,14 +121,14 @@ class VP9EncodePerfTest unsigned int threads_; }; -TEST_P(VP9EncodePerfTest, PerfTest) { - for (size_t i = 0; i < NELEMENTS(kVP9EncodePerfTestVectors); ++i) { +TEST_P(AV1EncodePerfTest, PerfTest) { + for (size_t i = 0; i < NELEMENTS(kAV1EncodePerfTestVectors); ++i) { for (size_t j = 0; j < NELEMENTS(kEncodePerfTestSpeeds); ++j) { for (size_t k = 0; k < NELEMENTS(kEncodePerfTestThreads); ++k) { - if (kVP9EncodePerfTestVectors[i].width < 512 && + if (kAV1EncodePerfTestVectors[i].width < 512 && kEncodePerfTestThreads[k] > 1) continue; - else if (kVP9EncodePerfTestVectors[i].width < 1024 && + else if (kAV1EncodePerfTestVectors[i].width < 1024 && kEncodePerfTestThreads[k] > 2) continue; @@ -137,16 +137,16 @@ TEST_P(VP9EncodePerfTest, PerfTest) { const aom_rational timebase = { 33333333, 1000000000 }; cfg_.g_timebase = timebase; - cfg_.rc_target_bitrate = kVP9EncodePerfTestVectors[i].bitrate; + cfg_.rc_target_bitrate = kAV1EncodePerfTestVectors[i].bitrate; init_flags_ = AOM_CODEC_USE_PSNR; - const unsigned frames = kVP9EncodePerfTestVectors[i].frames; - const char *video_name = kVP9EncodePerfTestVectors[i].name; + const unsigned frames = kAV1EncodePerfTestVectors[i].frames; + const char *video_name = kAV1EncodePerfTestVectors[i].name; libaom_test::I420VideoSource video( - video_name, kVP9EncodePerfTestVectors[i].width, - kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0, - kVP9EncodePerfTestVectors[i].frames); + video_name, kAV1EncodePerfTestVectors[i].width, + kAV1EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0, + kAV1EncodePerfTestVectors[i].frames); set_speed(kEncodePerfTestSpeeds[j]); aom_usec_timer t; @@ -182,6 +182,6 @@ TEST_P(VP9EncodePerfTest, PerfTest) { } } -AV1_INSTANTIATE_TEST_CASE(VP9EncodePerfTest, +AV1_INSTANTIATE_TEST_CASE(AV1EncodePerfTest, ::testing::Values(::libaom_test::kRealTime)); } // namespace diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc index 4d31f93e7..cd132fea1 100644 --- a/test/encode_test_driver.cc +++ b/test/encode_test_driver.cc @@ -37,7 +37,7 @@ void Encoder::InitEncoder(VideoSource *video) { if (CodecInterface() == &aom_codec_av1_cx_algo) { // Default to 1 tile column for AV1. const int log2_tile_columns = 0; - res = aom_codec_control_(&encoder_, VP9E_SET_TILE_COLUMNS, + res = aom_codec_control_(&encoder_, AV1E_SET_TILE_COLUMNS, log2_tile_columns); ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError(); } diff --git a/test/encoder_parms_get_to_decoder.cc b/test/encoder_parms_get_to_decoder.cc index aaedbca9f..0bd185b9f 100644 --- a/test/encoder_parms_get_to_decoder.cc +++ b/test/encoder_parms_get_to_decoder.cc @@ -28,7 +28,7 @@ struct EncodePerfTestVideo { int frames; }; -const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = { +const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = { { "niklas_1280_720_30.y4m", 1280, 720, 600, 10 }, }; @@ -44,7 +44,7 @@ struct EncodeParameters { // TODO(JBB): quantizers / bitrate }; -const EncodeParameters kVP9EncodeParameterSet[] = { +const EncodeParameters kAV1EncodeParameterSet[] = { { 0, 0, 0, 1, 0, AOM_CR_STUDIO_RANGE, AOM_CS_BT_601 }, { 0, 0, 0, 0, 0, AOM_CR_FULL_RANGE, AOM_CS_BT_709 }, { 0, 0, 1, 0, 0, AOM_CR_FULL_RANGE, AOM_CS_BT_2020 }, @@ -75,20 +75,20 @@ class VpxEncoderParmsGetToDecoder virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video, ::libaom_test::Encoder *encoder) { if (video->frame() == 1) { - encoder->Control(VP9E_SET_COLOR_SPACE, encode_parms.cs); - encoder->Control(VP9E_SET_COLOR_RANGE, encode_parms.color_range); - encoder->Control(VP9E_SET_LOSSLESS, encode_parms.lossless); - encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, + encoder->Control(AV1E_SET_COLOR_SPACE, encode_parms.cs); + encoder->Control(AV1E_SET_COLOR_RANGE, encode_parms.color_range); + encoder->Control(AV1E_SET_LOSSLESS, encode_parms.lossless); + encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 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(AV1E_SET_TILE_ROWS, encode_parms.tile_rows); + encoder->Control(AV1E_SET_TILE_COLUMNS, encode_parms.tile_cols); 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); + encoder->Control(AV1E_SET_RENDER_SIZE, encode_parms.render_size); } } @@ -144,6 +144,6 @@ TEST_P(VpxEncoderParmsGetToDecoder, BitstreamParms) { } AV1_INSTANTIATE_TEST_CASE(VpxEncoderParmsGetToDecoder, - ::testing::ValuesIn(kVP9EncodeParameterSet), - ::testing::ValuesIn(kVP9EncodePerfTestVectors)); + ::testing::ValuesIn(kAV1EncodeParameterSet), + ::testing::ValuesIn(kAV1EncodePerfTestVectors)); } // namespace diff --git a/test/end_to_end_test.cc b/test/end_to_end_test.cc index a97e518a4..8d3b0a28e 100644 --- a/test/end_to_end_test.cc +++ b/test/end_to_end_test.cc @@ -114,8 +114,8 @@ class EndToEndTestLarge virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video, ::libaom_test::Encoder *encoder) { if (video->frame() == 1) { - encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1); - encoder->Control(VP9E_SET_TILE_COLUMNS, 4); + encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1); + encoder->Control(AV1E_SET_TILE_COLUMNS, 4); encoder->Control(AOME_SET_CPUUSED, cpu_used_); if (encoding_mode_ != ::libaom_test::kRealTime) { encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1); diff --git a/test/ethread_test.cc b/test/ethread_test.cc index 3282defcd..b0b85befc 100644 --- a/test/ethread_test.cc +++ b/test/ethread_test.cc @@ -61,7 +61,7 @@ class VPxEncoderThreadTest ::libaom_test::Encoder *encoder) { if (!encoder_initialized_) { // Encode 4 column tiles. - encoder->Control(VP9E_SET_TILE_COLUMNS, tiles_); + encoder->Control(AV1E_SET_TILE_COLUMNS, tiles_); encoder->Control(AOME_SET_CPUUSED, set_cpu_used_); if (encoding_mode_ != ::libaom_test::kRealTime) { encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1); @@ -70,7 +70,7 @@ class VPxEncoderThreadTest encoder->Control(AOME_SET_ARNR_TYPE, 3); } else { encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0); - encoder->Control(VP9E_SET_AQ_MODE, 3); + encoder->Control(AV1E_SET_AQ_MODE, 3); } encoder_initialized_ = true; } diff --git a/test/frame_size_tests.cc b/test/frame_size_tests.cc index 63b839c88..4faa304d6 100644 --- a/test/frame_size_tests.cc +++ b/test/frame_size_tests.cc @@ -13,12 +13,12 @@ namespace { -class VP9FrameSizeTestsLarge : public ::libaom_test::EncoderTest, +class AV1FrameSizeTestsLarge : public ::libaom_test::EncoderTest, public ::testing::Test { protected: - VP9FrameSizeTestsLarge() + AV1FrameSizeTestsLarge() : EncoderTest(&::libaom_test::kAV1), expected_res_(AOM_CODEC_OK) {} - virtual ~VP9FrameSizeTestsLarge() {} + virtual ~AV1FrameSizeTestsLarge() {} virtual void SetUp() { InitializeConfig(); @@ -46,7 +46,7 @@ class VP9FrameSizeTestsLarge : public ::libaom_test::EncoderTest, int expected_res_; }; -TEST_F(VP9FrameSizeTestsLarge, TestInvalidSizes) { +TEST_F(AV1FrameSizeTestsLarge, TestInvalidSizes) { ::libaom_test::RandomVideoSource video; #if CONFIG_SIZE_LIMIT @@ -57,7 +57,7 @@ TEST_F(VP9FrameSizeTestsLarge, TestInvalidSizes) { #endif } -TEST_F(VP9FrameSizeTestsLarge, ValidSizes) { +TEST_F(AV1FrameSizeTestsLarge, ValidSizes) { ::libaom_test::RandomVideoSource video; #if CONFIG_SIZE_LIMIT @@ -84,7 +84,7 @@ TEST_F(VP9FrameSizeTestsLarge, ValidSizes) { #endif } -TEST_F(VP9FrameSizeTestsLarge, OneByOneVideo) { +TEST_F(AV1FrameSizeTestsLarge, OneByOneVideo) { ::libaom_test::RandomVideoSource video; video.SetSize(1, 1); diff --git a/test/idct8x8_test.cc b/test/idct8x8_test.cc index 3d9f926a7..f212e9463 100644 --- a/test/idct8x8_test.cc +++ b/test/idct8x8_test.cc @@ -61,7 +61,7 @@ void reference_dct_2d(int16_t input[64], double output[64]) { for (int i = 0; i < 64; ++i) output[i] *= 2; } -TEST(VP9Idct8x8Test, AccuracyCheck) { +TEST(AV1Idct8x8Test, AccuracyCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); const int count_test_block = 10000; for (int i = 0; i < count_test_block; ++i) { diff --git a/test/intrapred_test.cc b/test/intrapred_test.cc index 0efd0f29d..36b5301df 100644 --- a/test/intrapred_test.cc +++ b/test/intrapred_test.cc @@ -28,10 +28,10 @@ using libaom_test::ACMRandom; const int count_test_block = 100000; -// Base class for VP9 intra prediction tests. -class VP9IntraPredBase { +// Base class for AV1 intra prediction tests. +class AV1IntraPredBase { public: - virtual ~VP9IntraPredBase() { libaom_test::ClearSystemState(); } + virtual ~AV1IntraPredBase() { libaom_test::ClearSystemState(); } protected: virtual void Predict(PREDICTION_MODE mode) = 0; @@ -93,7 +93,7 @@ typedef void (*intra_pred_fn_t)(uint16_t *dst, ptrdiff_t stride, int bps); typedef std::tr1::tuple intra_pred_params_t; -class VP9IntraPredTest : public VP9IntraPredBase, +class AV1IntraPredTest : public AV1IntraPredBase, public ::testing::TestWithParam { virtual void SetUp() { pred_fn_ = GET_PARAM(0); @@ -116,7 +116,7 @@ class VP9IntraPredTest : public VP9IntraPredBase, int bit_depth_; }; -TEST_P(VP9IntraPredTest, IntraPredTests) { +TEST_P(AV1IntraPredTest, IntraPredTests) { // max block size is 32 DECLARE_ALIGNED(16, uint16_t, left_col[2 * 32]); DECLARE_ALIGNED(16, uint16_t, above_data[2 * 32 + 32]); @@ -131,7 +131,7 @@ using std::tr1::make_tuple; #if CONFIG_AOM_HIGHBITDEPTH #if CONFIG_USE_X86INC INSTANTIATE_TEST_CASE_P( - SSE2_TO_C_8, VP9IntraPredTest, + SSE2_TO_C_8, AV1IntraPredTest, ::testing::Values(make_tuple(&aom_highbd_dc_predictor_32x32_sse2, &aom_highbd_dc_predictor_32x32_c, 32, 8), make_tuple(&aom_highbd_tm_predictor_16x16_sse2, @@ -158,7 +158,7 @@ INSTANTIATE_TEST_CASE_P( &aom_highbd_tm_predictor_8x8_c, 8, 8))); INSTANTIATE_TEST_CASE_P( - SSE2_TO_C_10, VP9IntraPredTest, + SSE2_TO_C_10, AV1IntraPredTest, ::testing::Values(make_tuple(&aom_highbd_dc_predictor_32x32_sse2, &aom_highbd_dc_predictor_32x32_c, 32, 10), make_tuple(&aom_highbd_tm_predictor_16x16_sse2, @@ -185,7 +185,7 @@ INSTANTIATE_TEST_CASE_P( &aom_highbd_tm_predictor_8x8_c, 8, 10))); INSTANTIATE_TEST_CASE_P( - SSE2_TO_C_12, VP9IntraPredTest, + SSE2_TO_C_12, AV1IntraPredTest, ::testing::Values(make_tuple(&aom_highbd_dc_predictor_32x32_sse2, &aom_highbd_dc_predictor_32x32_c, 32, 12), make_tuple(&aom_highbd_tm_predictor_16x16_sse2, diff --git a/test/lossless_test.cc b/test/lossless_test.cc index 4c2a1474f..fb9080bd0 100644 --- a/test/lossless_test.cc +++ b/test/lossless_test.cc @@ -42,7 +42,7 @@ class LosslessTest // Only call Control if quantizer > 0 to verify that using quantizer // alone will activate lossless if (cfg_.rc_max_quantizer > 0 || cfg_.rc_min_quantizer > 0) { - encoder->Control(VP9E_SET_LOSSLESS, 1); + encoder->Control(AV1E_SET_LOSSLESS, 1); } } } diff --git a/test/quantize_test.cc b/test/quantize_test.cc index a9a1b3ec1..e0fd24762 100644 --- a/test/quantize_test.cc +++ b/test/quantize_test.cc @@ -42,9 +42,9 @@ typedef void (*QuantizeFunc)(const tran_low_t *coeff, intptr_t count, typedef std::tr1::tuple QuantizeParam; -class VP9QuantizeTest : public ::testing::TestWithParam { +class AV1QuantizeTest : public ::testing::TestWithParam { public: - virtual ~VP9QuantizeTest() {} + virtual ~AV1QuantizeTest() {} virtual void SetUp() { quantize_op_ = GET_PARAM(0); ref_quantize_op_ = GET_PARAM(1); @@ -61,9 +61,9 @@ class VP9QuantizeTest : public ::testing::TestWithParam { QuantizeFunc ref_quantize_op_; }; -class VP9Quantize32Test : public ::testing::TestWithParam { +class AV1Quantize32Test : public ::testing::TestWithParam { public: - virtual ~VP9Quantize32Test() {} + virtual ~AV1Quantize32Test() {} virtual void SetUp() { quantize_op_ = GET_PARAM(0); ref_quantize_op_ = GET_PARAM(1); @@ -80,7 +80,7 @@ class VP9Quantize32Test : public ::testing::TestWithParam { QuantizeFunc ref_quantize_op_; }; -TEST_P(VP9QuantizeTest, OperationCheck) { +TEST_P(AV1QuantizeTest, OperationCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); DECLARE_ALIGNED(16, tran_low_t, coeff_ptr[256]); DECLARE_ALIGNED(16, int16_t, zbin_ptr[2]); @@ -138,7 +138,7 @@ TEST_P(VP9QuantizeTest, OperationCheck) { << "First failed at test case " << first_failure; } -TEST_P(VP9Quantize32Test, OperationCheck) { +TEST_P(AV1Quantize32Test, OperationCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); DECLARE_ALIGNED(16, tran_low_t, coeff_ptr[1024]); DECLARE_ALIGNED(16, int16_t, zbin_ptr[2]); @@ -196,7 +196,7 @@ TEST_P(VP9Quantize32Test, OperationCheck) { << "First failed at test case " << first_failure; } -TEST_P(VP9QuantizeTest, EOBCheck) { +TEST_P(AV1QuantizeTest, EOBCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); DECLARE_ALIGNED(16, tran_low_t, coeff_ptr[256]); DECLARE_ALIGNED(16, int16_t, zbin_ptr[2]); @@ -259,7 +259,7 @@ TEST_P(VP9QuantizeTest, EOBCheck) { << "First failed at test case " << first_failure; } -TEST_P(VP9Quantize32Test, EOBCheck) { +TEST_P(AV1Quantize32Test, EOBCheck) { ACMRandom rnd(ACMRandom::DeterministicSeed()); DECLARE_ALIGNED(16, tran_low_t, coeff_ptr[1024]); DECLARE_ALIGNED(16, int16_t, zbin_ptr[2]); @@ -325,7 +325,7 @@ using std::tr1::make_tuple; #if HAVE_SSE2 INSTANTIATE_TEST_CASE_P( - SSE2, VP9QuantizeTest, + SSE2, AV1QuantizeTest, ::testing::Values(make_tuple(&aom_highbd_quantize_b_sse2, &aom_highbd_quantize_b_c, AOM_BITS_8), make_tuple(&aom_highbd_quantize_b_sse2, @@ -333,7 +333,7 @@ INSTANTIATE_TEST_CASE_P( make_tuple(&aom_highbd_quantize_b_sse2, &aom_highbd_quantize_b_c, AOM_BITS_12))); INSTANTIATE_TEST_CASE_P( - SSE2, VP9Quantize32Test, + SSE2, AV1Quantize32Test, ::testing::Values(make_tuple(&aom_highbd_quantize_b_32x32_sse2, &aom_highbd_quantize_b_32x32_c, AOM_BITS_8), make_tuple(&aom_highbd_quantize_b_32x32_sse2, diff --git a/test/resize_test.cc b/test/resize_test.cc index b44055ecc..d1ac95a01 100644 --- a/test/resize_test.cc +++ b/test/resize_test.cc @@ -286,7 +286,7 @@ class ResizeRealtimeTest virtual void PreEncodeFrameHook(libaom_test::VideoSource *video, libaom_test::Encoder *encoder) { if (video->frame() == 0) { - encoder->Control(VP9E_SET_AQ_MODE, 3); + encoder->Control(AV1E_SET_AQ_MODE, 3); encoder->Control(AOME_SET_CPUUSED, set_cpu_used_); } diff --git a/test/simple_decoder.sh b/test/simple_decoder.sh index 32c713459..42ea91002 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: -# $AOM_IVF_FILE and $VP9_IVF_FILE are required. +# $AOM_IVF_FILE and $AV1_IVF_FILE are required. simple_decoder_verify_environment() { - if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then + if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then echo "Libaom test data must exist in LIBAOM_TEST_DATA_PATH." return 1 fi @@ -51,7 +51,7 @@ simple_decoder_vp8() { simple_decoder_vp9() { if [ "$(vp9_decode_available)" = "yes" ]; then - simple_decoder "${VP9_IVF_FILE}" vp9 || return 1 + simple_decoder "${AV1_IVF_FILE}" vp9 || return 1 fi } diff --git a/test/simple_encoder.sh b/test/simple_encoder.sh index 62b6fc479..93153514c 100755 --- a/test/simple_encoder.sh +++ b/test/simple_encoder.sh @@ -48,7 +48,7 @@ simple_encoder_vp8() { } # TODO(tomfinegan): Add a frame limit param to simple_encoder and enable this -# test. VP9 is just too slow right now: This test takes 4m30s+ on a fast +# test. AV1 is just too slow right now: This test takes 4m30s+ on a fast # machine. DISABLED_simple_encoder_vp9() { if [ "$(vp9_encode_available)" = "yes" ]; then diff --git a/test/subtract_test.cc b/test/subtract_test.cc index b23b9ab83..b8daa6f1b 100644 --- a/test/subtract_test.cc +++ b/test/subtract_test.cc @@ -26,14 +26,14 @@ typedef void (*SubtractFunc)(int rows, int cols, int16_t *diff_ptr, namespace vp9 { -class VP9SubtractBlockTest : public ::testing::TestWithParam { +class AV1SubtractBlockTest : public ::testing::TestWithParam { public: virtual void TearDown() { libaom_test::ClearSystemState(); } }; using libaom_test::ACMRandom; -TEST_P(VP9SubtractBlockTest, SimpleSubtract) { +TEST_P(AV1SubtractBlockTest, SimpleSubtract) { ACMRandom rnd(ACMRandom::DeterministicSeed()); // FIXME(rbultje) split in its own file @@ -85,19 +85,19 @@ TEST_P(VP9SubtractBlockTest, SimpleSubtract) { } } -INSTANTIATE_TEST_CASE_P(C, VP9SubtractBlockTest, +INSTANTIATE_TEST_CASE_P(C, AV1SubtractBlockTest, ::testing::Values(aom_subtract_block_c)); #if HAVE_SSE2 && CONFIG_USE_X86INC -INSTANTIATE_TEST_CASE_P(SSE2, VP9SubtractBlockTest, +INSTANTIATE_TEST_CASE_P(SSE2, AV1SubtractBlockTest, ::testing::Values(aom_subtract_block_sse2)); #endif #if HAVE_NEON -INSTANTIATE_TEST_CASE_P(NEON, VP9SubtractBlockTest, +INSTANTIATE_TEST_CASE_P(NEON, AV1SubtractBlockTest, ::testing::Values(aom_subtract_block_neon)); #endif #if HAVE_MSA -INSTANTIATE_TEST_CASE_P(MSA, VP9SubtractBlockTest, +INSTANTIATE_TEST_CASE_P(MSA, AV1SubtractBlockTest, ::testing::Values(aom_subtract_block_msa)); #endif diff --git a/test/svc_test.cc b/test/svc_test.cc index 0efb27a2e..20c025699 100644 --- a/test/svc_test.cc +++ b/test/svc_test.cc @@ -25,7 +25,7 @@ namespace { using libaom_test::CodecFactory; using libaom_test::Decoder; using libaom_test::DxDataIterator; -using libaom_test::VP9CodecFactory; +using libaom_test::AV1CodecFactory; class SvcTest : public ::testing::Test { protected: @@ -59,7 +59,7 @@ class SvcTest : public ::testing::Test { codec_enc_.kf_max_dist = 100; aom_codec_dec_cfg_t dec_cfg = aom_codec_dec_cfg_t(); - VP9CodecFactory codec_factory; + AV1CodecFactory codec_factory; decoder_ = codec_factory.CreateDecoder(dec_cfg, 0); tile_columns_ = 0; @@ -76,8 +76,8 @@ class SvcTest : public ::testing::Test { aom_svc_init(&svc_, &codec_, aom_codec_vp9_cx(), &codec_enc_); EXPECT_EQ(AOM_CODEC_OK, res); 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_); + aom_codec_control(&codec_, AV1E_SET_TILE_COLUMNS, tile_columns_); + aom_codec_control(&codec_, AV1E_SET_TILE_ROWS, tile_rows_); codec_initialized_ = true; } diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc index 15ad23a0b..227edb8c8 100644 --- a/test/tile_independence_test.cc +++ b/test/tile_independence_test.cc @@ -33,7 +33,7 @@ class TileIndependenceTest : public ::libaom_test::EncoderTest, cfg.threads = 1; fw_dec_ = codec_->CreateDecoder(cfg, 0); inv_dec_ = codec_->CreateDecoder(cfg, 0); - inv_dec_->Control(VP9_INVERT_TILE_DECODE_ORDER, 1); + inv_dec_->Control(AV1_INVERT_TILE_DECODE_ORDER, 1); } virtual ~TileIndependenceTest() { @@ -49,7 +49,7 @@ class TileIndependenceTest : public ::libaom_test::EncoderTest, virtual void PreEncodeFrameHook(libaom_test::VideoSource *video, libaom_test::Encoder *encoder) { if (video->frame() == 1) { - encoder->Control(VP9E_SET_TILE_COLUMNS, n_tiles_); + encoder->Control(AV1E_SET_TILE_COLUMNS, n_tiles_); } } diff --git a/test/tools_common.sh b/test/tools_common.sh index 01fcbb7c5..94cbebe14 100755 --- a/test/tools_common.sh +++ b/test/tools_common.sh @@ -384,11 +384,11 @@ fi # Variables shared by tests. 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" +AV1_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" -VP9_FPM_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-07-frame_parallel-1.webm" -VP9_LT_50_FRAMES_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-02-size-32x08.webm" +AV1_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-00-quantizer-00.webm" +AV1_FPM_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-07-frame_parallel-1.webm" +AV1_LT_50_FRAMES_WEBM_FILE="${LIBAOM_TEST_DATA_PATH}/vp90-2-02-size-32x08.webm" YUV_RAW_INPUT="${LIBAOM_TEST_DATA_PATH}/hantro_collage_w352h288.yuv" YUV_RAW_INPUT_WIDTH=352 @@ -405,8 +405,8 @@ vlog "$(basename "${0%.*}") test configuration: LIBAOM_CONFIG_PATH=${LIBAOM_CONFIG_PATH} LIBAOM_TEST_DATA_PATH=${LIBAOM_TEST_DATA_PATH} AOM_IVF_FILE=${AOM_IVF_FILE} - VP9_IVF_FILE=${VP9_IVF_FILE} - VP9_WEBM_FILE=${VP9_WEBM_FILE} + AV1_IVF_FILE=${AV1_IVF_FILE} + AV1_WEBM_FILE=${AV1_WEBM_FILE} AOM_TEST_EXE_SUFFIX=${AOM_TEST_EXE_SUFFIX} AOM_TEST_FILTER=${AOM_TEST_FILTER} AOM_TEST_LIST_TESTS=${AOM_TEST_LIST_TESTS} diff --git a/test/twopass_encoder.sh b/test/twopass_encoder.sh index bd59189d5..73f993cbf 100755 --- a/test/twopass_encoder.sh +++ b/test/twopass_encoder.sh @@ -48,7 +48,7 @@ twopass_encoder_vp8() { } # TODO(tomfinegan): Add a frame limit param to twopass_encoder and enable this -# test. VP9 is just too slow right now: This test takes 31m16s+ on a fast +# test. AV1 is just too slow right now: This test takes 31m16s+ on a fast # machine. DISABLED_twopass_encoder_vp9() { if [ "$(vp9_encode_available)" = "yes" ]; then diff --git a/third_party/libwebm/mkvmuxer.cpp b/third_party/libwebm/mkvmuxer.cpp index f55fc98f3..bd1132d45 100644 --- a/third_party/libwebm/mkvmuxer.cpp +++ b/third_party/libwebm/mkvmuxer.cpp @@ -1044,7 +1044,7 @@ bool AudioTrack::Write(IMkvWriter* writer) const { const char Tracks::kOpusCodecId[] = "A_OPUS"; const char Tracks::kVorbisCodecId[] = "A_VORBIS"; const char Tracks::kVp8CodecId[] = "V_AOM"; -const char Tracks::kVp9CodecId[] = "V_VP9"; +const char Tracks::kVp9CodecId[] = "V_AV1"; const char Tracks::kAV1CodecId[] = "V_AV1"; Tracks::Tracks() : track_entries_(NULL), track_entries_size_(0) {} diff --git a/tools_common.h b/tools_common.h index 9fd30695a..1fdb6a6a3 100644 --- a/tools_common.h +++ b/tools_common.h @@ -61,9 +61,7 @@ #define RAW_FRAME_HDR_SZ sizeof(uint32_t) -#define AOM_FOURCC 0x30385056 -#define VP9_FOURCC 0x30395056 -#define AV1_FOURCC 0x303a5056 +#define AV1_FOURCC 0x31305641 enum VideoFileType { FILE_TYPE_RAW, diff --git a/webmdec.cc b/webmdec.cc index af0be9e1b..0d8c8a876 100644 --- a/webmdec.cc +++ b/webmdec.cc @@ -99,11 +99,7 @@ int file_is_webm(struct WebmInputContext *webm_ctx, return 0; } - 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)) { + if (!strncmp(video_track->GetCodecId(), "V_AV1", 5)) { aom_ctx->fourcc = AV1_FOURCC; } else { rewind_and_reset(webm_ctx, aom_ctx); diff --git a/webmenc.cc b/webmenc.cc index 50fe1a653..2ee8363c5 100644 --- a/webmenc.cc +++ b/webmenc.cc @@ -48,8 +48,6 @@ void write_webm_file_header(struct EbmlGlobal *glob, video_track->SetStereoMode(stereo_fmt); const char *codec_id; switch (fourcc) { - 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; }