mozilla
/
aom
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Change "vp10" to "av1" in source code 

Change-Id: Ifd0d08b97538dcc04227eceb6fb087224c760c59
This commit is contained in:
Yaowu Xu 2016-03-25 12:43:01 -07:00
Родитель cebe6f0cf5
Коммит 01dee0bba5
265 изменённых файлов: 5083 добавлений и 5083 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

14
aom/aom_codec.mk
Просмотреть файл

@ -12,14 +12,14 @@
API_EXPORTS += exports
API_SRCS-$(CONFIG_V10_ENCODER) += vp8.h
API_SRCS-$(CONFIG_VP10_ENCODER) += vp8cx.h
API_DOC_SRCS-$(CONFIG_VP10_ENCODER) += vp8.h
API_DOC_SRCS-$(CONFIG_VP10_ENCODER) += vp8cx.h
API_SRCS-$(CONFIG_AV1_ENCODER) += vp8cx.h
API_DOC_SRCS-$(CONFIG_AV1_ENCODER) += vp8.h
API_DOC_SRCS-$(CONFIG_AV1_ENCODER) += vp8cx.h
API_SRCS-$(CONFIG_VP10_DECODER) += vp8.h
API_SRCS-$(CONFIG_VP10_DECODER) += vp8dx.h
API_DOC_SRCS-$(CONFIG_VP10_DECODER) += vp8.h
API_DOC_SRCS-$(CONFIG_VP10_DECODER) += vp8dx.h
API_SRCS-$(CONFIG_AV1_DECODER) += vp8.h
API_SRCS-$(CONFIG_AV1_DECODER) += vp8dx.h
API_DOC_SRCS-$(CONFIG_AV1_DECODER) += vp8.h
API_DOC_SRCS-$(CONFIG_AV1_DECODER) += vp8dx.h
API_DOC_SRCS-yes += aom_codec.h
API_DOC_SRCS-yes += aom_decoder.h

8
aom/vp8cx.h
Просмотреть файл

@ -28,13 +28,13 @@
extern "C" {
#endif
/*!\name Algorithm interface for VP10
/*!\name Algorithm interface for AV1
*
* This interface provides the capability to encode raw VP10 streams.
* This interface provides the capability to encode raw AV1 streams.
* @{
*/
extern aom_codec_iface_t aom_codec_vp10_cx_algo;
extern aom_codec_iface_t *aom_codec_vp10_cx(void);
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*/
/*

8
aom/vp8dx.h
Просмотреть файл

@ -28,13 +28,13 @@ extern "C" {
/* Include controls common to both the encoder and decoder */
#include "./vp8.h"
/*!\name Algorithm interface for VP10
/*!\name Algorithm interface for AV1
*
* This interface provides the capability to decode VP10 streams.
* This interface provides the capability to decode AV1 streams.
* @{
*/
extern aom_codec_iface_t aom_codec_vp10_dx_algo;
extern aom_codec_iface_t *aom_codec_vp10_dx(void);
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

2
aom_dsp/aom_convolve.c
Просмотреть файл

@ -329,7 +329,7 @@ void aom_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
filter_y, y_step_q4, w, h);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void highbd_convolve_horiz(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *x_filters, int x0_q4,

2
aom_dsp/aom_convolve.h
Просмотреть файл

@ -24,7 +24,7 @@ typedef void (*convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y, int y_step_q4, int w,
int h);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
typedef void (*highbd_convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,

36
aom_dsp/aom_dsp.mk
Просмотреть файл

@ -45,12 +45,12 @@ DSP_SRCS-$(HAVE_SSSE3) += x86/intrapred_ssse3.asm
DSP_SRCS-$(HAVE_SSSE3) += x86/aom_subpixel_8t_ssse3.asm
endif # CONFIG_USE_X86INC
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_USE_X86INC),yes)
DSP_SRCS-$(HAVE_SSE) += x86/highbd_intrapred_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_intrapred_sse2.asm
endif # CONFIG_USE_X86INC
endif # CONFIG_VPX_HIGHBITDEPTH
endif # CONFIG_AOM_HIGHBITDEPTH
DSP_SRCS-$(HAVE_NEON_ASM) += arm/intrapred_neon_asm$(ASM)
DSP_SRCS-$(HAVE_NEON) += arm/intrapred_neon.c
@ -75,7 +75,7 @@ DSP_SRCS-$(HAVE_SSSE3) += x86/aom_subpixel_8t_ssse3.asm
DSP_SRCS-$(HAVE_SSSE3) += x86/aom_subpixel_bilinear_ssse3.asm
DSP_SRCS-$(HAVE_AVX2) += x86/aom_subpixel_8t_intrin_avx2.c
DSP_SRCS-$(HAVE_SSSE3) += x86/aom_subpixel_8t_intrin_ssse3.c
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/aom_high_subpixel_8t_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/aom_high_subpixel_bilinear_sse2.asm
endif
@ -156,15 +156,15 @@ DSP_SRCS-$(HAVE_DSPR2) += mips/loopfilter_mb_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/loopfilter_mb_horiz_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/loopfilter_mb_vert_dspr2.c
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_loopfilter_sse2.c
endif # CONFIG_VPX_HIGHBITDEPTH
endif # CONFIG_AOM_HIGHBITDEPTH
DSP_SRCS-yes += txfm_common.h
DSP_SRCS-$(HAVE_SSE2) += x86/txfm_common_sse2.h
DSP_SRCS-$(HAVE_MSA) += mips/txfm_macros_msa.h
# forward transform
ifneq ($(filter yes,$(CONFIG_VP10_ENCODER)),)
ifneq ($(filter yes,$(CONFIG_AV1_ENCODER)),)
DSP_SRCS-yes += fwd_txfm.c
DSP_SRCS-yes += fwd_txfm.h
DSP_SRCS-$(HAVE_SSE2) += x86/fwd_txfm_sse2.h
@ -182,10 +182,10 @@ DSP_SRCS-$(HAVE_NEON) += arm/fwd_txfm_neon.c
DSP_SRCS-$(HAVE_MSA) += mips/fwd_txfm_msa.h
DSP_SRCS-$(HAVE_MSA) += mips/fwd_txfm_msa.c
DSP_SRCS-$(HAVE_MSA) += mips/fwd_dct32x32_msa.c
endif # CONFIG_VP10_ENCODER
endif # CONFIG_AV1_ENCODER
# inverse transform
ifneq ($(filter yes,$(CONFIG_VP10)),)
ifneq ($(filter yes,$(CONFIG_AV1)),)
DSP_SRCS-yes += inv_txfm.h
DSP_SRCS-yes += inv_txfm.c
DSP_SRCS-$(HAVE_SSE2) += x86/inv_txfm_sse2.h
@ -227,23 +227,23 @@ DSP_SRCS-$(HAVE_MSA) += mips/idct8x8_msa.c
DSP_SRCS-$(HAVE_MSA) += mips/idct16x16_msa.c
DSP_SRCS-$(HAVE_MSA) += mips/idct32x32_msa.c
ifneq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifneq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_DSPR2) += mips/inv_txfm_dspr2.h
DSP_SRCS-$(HAVE_DSPR2) += mips/itrans4_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/itrans8_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/itrans16_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/itrans32_dspr2.c
DSP_SRCS-$(HAVE_DSPR2) += mips/itrans32_cols_dspr2.c
endif # CONFIG_VPX_HIGHBITDEPTH
endif # CONFIG_VP10
endif # CONFIG_AOM_HIGHBITDEPTH
endif # CONFIG_AV1
# quantization
ifneq ($(filter yes, $(CONFIG_VP10_ENCODER)),)
ifneq ($(filter yes, $(CONFIG_AV1_ENCODER)),)
DSP_SRCS-yes += quantize.c
DSP_SRCS-yes += quantize.h
DSP_SRCS-$(HAVE_SSE2) += x86/quantize_sse2.c
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_quantize_intrin_sse2.c
endif
ifeq ($(ARCH_X86_64),yes)
@ -264,7 +264,7 @@ DSP_SRCS-$(HAVE_SSSE3) += x86/avg_ssse3_x86_64.asm
endif
endif
endif # CONFIG_VP10_ENCODER
endif # CONFIG_AV1_ENCODER
ifeq ($(CONFIG_ENCODERS),yes)
DSP_SRCS-yes += sad.c
@ -292,10 +292,10 @@ DSP_SRCS-$(HAVE_SSE2) += x86/sad4d_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/sad_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/subtract_sse2.asm
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_sad4d_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_sad_sse2.asm
endif # CONFIG_VPX_HIGHBITDEPTH
endif # CONFIG_AOM_HIGHBITDEPTH
endif # CONFIG_USE_X86INC
endif # CONFIG_ENCODERS
@ -334,13 +334,13 @@ DSP_SRCS-$(HAVE_SSE) += x86/subpel_variance_sse2.asm
DSP_SRCS-$(HAVE_SSE2) += x86/subpel_variance_sse2.asm # Contains SSE2 and SSSE3
endif # CONFIG_USE_X86INC
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_variance_sse2.c
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_variance_impl_sse2.asm
ifeq ($(CONFIG_USE_X86INC),yes)
DSP_SRCS-$(HAVE_SSE2) += x86/highbd_subpel_variance_impl_sse2.asm
endif # CONFIG_USE_X86INC
endif # CONFIG_VPX_HIGHBITDEPTH
endif # CONFIG_AOM_HIGHBITDEPTH
endif # CONFIG_ENCODERS
DSP_SRCS-no += $(DSP_SRCS_REMOVE-yes)

8
aom_dsp/aom_dsp_common.h
Просмотреть файл

@ -29,7 +29,7 @@ typedef uint16_t qm_val_t;
#define AOM_QM_BITS 6
#endif
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
// Note:
// tran_low_t is the datatype used for final transform coefficients.
// tran_high_t is the datatype used for intermediate transform stages.
@ -41,7 +41,7 @@ typedef int32_t tran_low_t;
// tran_high_t is the datatype used for intermediate transform stages.
typedef int32_t tran_high_t;
typedef int16_t tran_low_t;
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
static INLINE uint8_t clip_pixel(int val) {
return (val > 255) ? 255 : (val < 0) ? 0 : val;
@ -55,7 +55,7 @@ static INLINE double fclamp(double value, double low, double high) {
return value < low ? low : (value > high ? high : value);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE uint16_t clip_pixel_highbd(int val, int bd) {
switch (bd) {
case 8:
@ -64,7 +64,7 @@ static INLINE uint16_t clip_pixel_highbd(int val, int bd) {
case 12: return (uint16_t)clamp(val, 0, 4095);
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#ifdef __cplusplus
} // extern "C"

56
aom_dsp/aom_dsp_rtcd_defs.pl
Просмотреть файл

@ -256,7 +256,7 @@ add_proto qw/void aom_dc_128_predictor_32x32/, "uint8_t *dst, ptrdiff_t y_stride
specialize qw/aom_dc_128_predictor_32x32 msa neon/, "$sse2_x86inc";
# High bitdepth functions
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_d207_predictor_4x4/, "uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd";
specialize qw/aom_highbd_d207_predictor_4x4/;
@ -448,7 +448,7 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_dc_128_predictor_32x32/, "uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd";
specialize qw/aom_highbd_dc_128_predictor_32x32/;
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
#
# Sub Pixel Filters
@ -495,7 +495,7 @@ specialize qw/aom_scaled_avg_horiz/;
add_proto qw/void aom_scaled_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h";
specialize qw/aom_scaled_avg_vert/;
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
#
# Sub Pixel Filters
#
@ -522,7 +522,7 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_convolve8_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/aom_highbd_convolve8_avg_vert/, "$sse2_x86_64";
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
#
# Loopfilter
@ -565,7 +565,7 @@ specialize qw/aom_lpf_horizontal_4 mmx neon dspr2 msa/;
add_proto qw/void aom_lpf_horizontal_4_dual/, "uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1";
specialize qw/aom_lpf_horizontal_4_dual sse2 neon dspr2 msa/;
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_lpf_vertical_16/, "uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd";
specialize qw/aom_highbd_lpf_vertical_16 sse2/;
@ -598,7 +598,7 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_lpf_horizontal_4_dual/, "uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd";
specialize qw/aom_highbd_lpf_horizontal_4_dual sse2/;
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
#
# Encoder functions.
@ -607,8 +607,8 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
#
# Forward transform
#
if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/aom_fdct4x4 sse2/;
@ -686,13 +686,13 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/aom_fdct32x32_1 sse2 msa/;
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_VP10_ENCODER
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_AV1_ENCODER
#
# Inverse transform
if (aom_config("CONFIG_VP10") eq "yes") {
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AV1") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# Note as optimized versions of these functions are added we need to add a check to ensure
# that when CONFIG_EMULATE_HARDWARE is on, it defaults to the C versions only.
add_proto qw/void aom_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
@ -925,40 +925,40 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/aom_iwht4x4_16_add msa/, "$sse2_x86inc";
} # CONFIG_EMULATE_HARDWARE
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_VP10
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_AV1
#
# Quantization
#
if (aom_config("CONFIG_AOM_QM") eq "yes") {
if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
add_proto qw/void aom_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
add_proto qw/void aom_quantize_b_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
add_proto qw/void aom_highbd_quantize_b_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_VP10_ENCODER
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_AV1_ENCODER
} else {
if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
add_proto qw/void aom_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/aom_quantize_b sse2/, "$ssse3_x86_64_x86inc", "$avx_x86_64_x86inc";
add_proto qw/void aom_quantize_b_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/aom_quantize_b_32x32/, "$ssse3_x86_64_x86inc", "$avx_x86_64_x86inc";
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/aom_highbd_quantize_b sse2/;
add_proto qw/void aom_highbd_quantize_b_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/aom_highbd_quantize_b_32x32 sse2/;
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_VP10_ENCODER
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_AV1_ENCODER
} # CONFIG_AOM_QM
if (aom_config("CONFIG_ENCODERS") eq "yes") {
@ -1013,7 +1013,7 @@ specialize qw/aom_sad4x4 mmx neon msa/, "$sse2_x86inc";
#
# Avg
#
if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
add_proto qw/unsigned int aom_avg_8x8/, "const uint8_t *, int p";
specialize qw/aom_avg_8x8 sse2 neon msa/;
@ -1040,7 +1040,7 @@ if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
add_proto qw/int aom_vector_var/, "int16_t const *ref, int16_t const *src, const int bwl";
specialize qw/aom_vector_var neon sse2/;
} # CONFIG_VP10_ENCODER
} # CONFIG_AV1_ENCODER
add_proto qw/unsigned int aom_sad64x64_avg/, "const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred";
specialize qw/aom_sad64x64_avg avx2 msa/, "$sse2_x86inc";
@ -1187,7 +1187,7 @@ if (aom_config("CONFIG_INTERNAL_STATS") eq "yes") {
specialize qw/aom_ssim_parms_16x16/, "$sse2_x86_64";
}
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
#
# Block subtraction
#
@ -1387,7 +1387,7 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void aom_highbd_ssim_parms_8x8/, "const uint16_t *s, int sp, const uint16_t *r, int rp, uint32_t *sum_s, uint32_t *sum_r, uint32_t *sum_sq_s, uint32_t *sum_sq_r, uint32_t *sum_sxr";
specialize qw/aom_highbd_ssim_parms_8x8/;
}
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_ENCODERS
if (aom_config("CONFIG_ENCODERS") eq "yes") {
@ -1556,7 +1556,7 @@ add_proto qw/uint32_t aom_variance_halfpixvar16x16_v/, "const unsigned char *src
add_proto qw/uint32_t aom_variance_halfpixvar16x16_hv/, "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, uint32_t *sse";
specialize qw/aom_variance_halfpixvar16x16_hv mmx sse2 media/;
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/unsigned int aom_highbd_12_variance64x64/, "const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse";
specialize qw/aom_highbd_12_variance64x64 sse2/;
@ -1913,7 +1913,7 @@ if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/uint32_t aom_highbd_8_sub_pixel_avg_variance4x8/, "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred";
add_proto qw/uint32_t aom_highbd_8_sub_pixel_avg_variance4x4/, "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred";
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
} # CONFIG_ENCODERS
1;

4
aom_dsp/avg.c
Просмотреть файл

@ -189,7 +189,7 @@ void aom_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
unsigned int aom_highbd_avg_8x8_c(const uint8_t *s8, int p) {
int i, j;
int sum = 0;
@ -227,4 +227,4 @@ void aom_highbd_minmax_8x8_c(const uint8_t *s8, int p, const uint8_t *d8,
}
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

4
aom_dsp/fwd_txfm.c
Просмотреть файл

@ -770,7 +770,7 @@ void aom_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride) {
output[1] = 0;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output,
int stride) {
aom_fdct4x4_c(input, output, stride);
@ -809,4 +809,4 @@ void aom_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *out,
int stride) {
aom_fdct32x32_1_c(input, out, stride);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

8
aom_dsp/intrapred.c
Просмотреть файл

@ -490,7 +490,7 @@ void aom_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t stride,
DST(1, 3) = AVG3(L, K, J);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE void highbd_d207_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
@ -765,7 +765,7 @@ static INLINE void highbd_dc_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
dst += stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
// This serves as a wrapper function, so that all the prediction functions
// can be unified and accessed as a pointer array. Note that the boundary
@ -777,7 +777,7 @@ static INLINE void highbd_dc_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
type##_predictor(dst, stride, size, above, left); \
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
#define intra_pred_highbd_sized(type, size) \
void aom_highbd_##type##_predictor_##size##x##size##_c( \
uint16_t *dst, ptrdiff_t stride, const uint16_t *above, \
@ -806,7 +806,7 @@ static INLINE void highbd_dc_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
#define intra_pred_no_4x4(type) \
intra_pred_sized(type, 8) intra_pred_sized(type, 16) \
intra_pred_sized(type, 32)
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
/* clang-format off */
intra_pred_no_4x4(d207)

4
aom_dsp/inv_txfm.c
Просмотреть файл

@ -1251,7 +1251,7 @@ void aom_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
/* 4-point reversible, orthonormal inverse Walsh-Hadamard in 3.5 adds,
@ -2487,4 +2487,4 @@ void aom_highbd_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
dest += stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

6
aom_dsp/inv_txfm.h
Просмотреть файл

@ -41,7 +41,7 @@ static INLINE tran_low_t dct_const_round_shift(tran_high_t input) {
return check_range(rv);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE tran_low_t highbd_check_range(tran_high_t input, int bd) {
#if CONFIG_COEFFICIENT_RANGE_CHECKING
// For valid highbitdepth streams, intermediate stage coefficients will
@ -64,7 +64,7 @@ static INLINE tran_low_t highbd_dct_const_round_shift(tran_high_t input,
tran_high_t rv = ROUND_POWER_OF_TWO(input, DCT_CONST_BITS);
return highbd_check_range(rv, bd);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#if CONFIG_EMULATE_HARDWARE
// When CONFIG_EMULATE_HARDWARE is 1 the transform performs a
@ -96,7 +96,7 @@ void iadst4_c(const tran_low_t *input, tran_low_t *output);
void iadst8_c(const tran_low_t *input, tran_low_t *output);
void iadst16_c(const tran_low_t *input, tran_low_t *output);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd);
void aom_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd);
void aom_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd);

6
aom_dsp/loopfilter.c
Просмотреть файл

@ -19,7 +19,7 @@ static INLINE int8_t signed_char_clamp(int t) {
return (int8_t)clamp(t, -128, 127);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE int16_t signed_char_clamp_high(int t, int bd) {
switch (bd) {
case 10: return (int16_t)clamp(t, -128 * 4, 128 * 4 - 1);
@ -342,7 +342,7 @@ void aom_lpf_vertical_16_dual_c(uint8_t *s, int p, const uint8_t *blimit,
mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 16);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
// Should we apply any filter at all: 11111111 yes, 00000000 no ?
static INLINE int8_t highbd_filter_mask(uint8_t limit, uint8_t blimit,
uint16_t p3, uint16_t p2, uint16_t p1,
@ -706,4 +706,4 @@ void aom_highbd_lpf_vertical_16_dual_c(uint16_t *s, int p,
const uint8_t *thresh, int bd) {
highbd_mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 16, bd);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

16
aom_dsp/quantize.c
Просмотреть файл

@ -40,7 +40,7 @@ void aom_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs, int skip_block,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
int skip_block, const int16_t *round_ptr,
const int16_t quant, tran_low_t *qcoeff_ptr,
@ -99,7 +99,7 @@ void aom_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr,
@ -192,7 +192,7 @@ void aom_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr, const int16_t *quant_ptr,
@ -316,7 +316,7 @@ void aom_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_b_32x32_c(
const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr,
@ -400,7 +400,7 @@ void aom_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs, int skip_block,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
int skip_block, const int16_t *round_ptr,
const int16_t quant, tran_low_t *qcoeff_ptr,
@ -450,7 +450,7 @@ void aom_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr,
@ -527,7 +527,7 @@ void aom_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr, const int16_t *quant_ptr,
@ -632,7 +632,7 @@ void aom_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
*eob_ptr = eob + 1;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_b_32x32_c(
const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr,

4
aom_dsp/quantize.h
Просмотреть файл

@ -38,7 +38,7 @@ void aom_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
uint16_t *eob_ptr, const int16_t *scan,
const int16_t *iscan, const qm_val_t *qm_ptr,
const qm_val_t *iqm_ptr);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
int skip_block, const int16_t *round_ptr,
const int16_t quant_ptr, tran_low_t *qcoeff_ptr,
@ -75,7 +75,7 @@ void aom_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr,
uint16_t *eob_ptr, const int16_t *scan,
const int16_t *iscan);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
int skip_block, const int16_t *round_ptr,
const int16_t quant_ptr, tran_low_t *qcoeff_ptr,

8
aom_dsp/sad.c
Просмотреть файл

@ -54,7 +54,7 @@ static INLINE void avg_pred(uint8_t *comp_pred, const uint8_t *pred, int width,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE void highbd_avg_pred(uint16_t *comp_pred, const uint8_t *pred8,
int width, int height, const uint8_t *ref8,
int ref_stride) {
@ -71,7 +71,7 @@ static INLINE void highbd_avg_pred(uint16_t *comp_pred, const uint8_t *pred8,
ref += ref_stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#define sadMxN(m, n) \
unsigned int aom_sad##m##x##n##_c(const uint8_t *src, int src_stride, \
@ -179,7 +179,7 @@ sadMxNxK(4, 4, 8)
sadMxNx4D(4, 4)
/* clang-format on */
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE
unsigned int highbd_sad(const uint8_t *a8, int a_stride, const uint8_t *b8,
int b_stride, int width, int height) {
@ -317,4 +317,4 @@ highbd_sadMxNxK(4, 4, 8)
highbd_sadMxNx4D(4, 4)
/* clang-format on */
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

16
aom_dsp/ssim.c
Просмотреть файл

@ -45,7 +45,7 @@ void aom_ssim_parms_8x8_c(const uint8_t *s, int sp, const uint8_t *r, int rp,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_ssim_parms_8x8_c(const uint16_t *s, int sp, const uint16_t *r,
int rp, uint32_t *sum_s, uint32_t *sum_r,
uint32_t *sum_sq_s, uint32_t *sum_sq_r,
@ -61,7 +61,7 @@ void aom_highbd_ssim_parms_8x8_c(const uint16_t *s, int sp, const uint16_t *r,
}
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
static const int64_t cc1 = 26634; // (64^2*(.01*255)^2
static const int64_t cc2 = 239708; // (64^2*(.03*255)^2
@ -92,7 +92,7 @@ static double ssim_8x8(const uint8_t *s, int sp, const uint8_t *r, int rp) {
return similarity(sum_s, sum_r, sum_sq_s, sum_sq_r, sum_sxr, 64);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static double highbd_ssim_8x8(const uint16_t *s, int sp, const uint16_t *r,
int rp, unsigned int bd) {
uint32_t sum_s = 0, sum_r = 0, sum_sq_s = 0, sum_sq_r = 0, sum_sxr = 0;
@ -102,7 +102,7 @@ static double highbd_ssim_8x8(const uint16_t *s, int sp, const uint16_t *r,
return similarity(sum_s >> oshift, sum_r >> oshift, sum_sq_s >> (2 * oshift),
sum_sq_r >> (2 * oshift), sum_sxr >> (2 * oshift), 64);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
// We are using a 8x8 moving window with starting location of each 8x8 window
// on the 4x4 pixel grid. Such arrangement allows the windows to overlap
@ -127,7 +127,7 @@ static double aom_ssim2(const uint8_t *img1, const uint8_t *img2,
return ssim_total;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static double aom_highbd_ssim2(const uint8_t *img1, const uint8_t *img2,
int stride_img1, int stride_img2, int width,
int height, unsigned int bd) {
@ -149,7 +149,7 @@ static double aom_highbd_ssim2(const uint8_t *img1, const uint8_t *img2,
ssim_total /= samples;
return ssim_total;
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
double aom_calc_ssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, double *weight) {
@ -436,7 +436,7 @@ double aom_get_ssim_metrics(uint8_t *img1, int img1_pitch, uint8_t *img2,
return inconsistency_total;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
double aom_highbd_calc_ssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, double *weight,
unsigned int bd) {
@ -486,4 +486,4 @@ double aom_highbd_calc_ssimg(const YV12_BUFFER_CONFIG *source,
return ssim_all;
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

4
aom_dsp/ssim.h
Просмотреть файл

@ -80,7 +80,7 @@ double aom_psnrhvs(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, double *ssim_y,
double *ssim_u, double *ssim_v);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
double aom_highbd_calc_ssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, double *weight,
unsigned int bd);
@ -88,7 +88,7 @@ double aom_highbd_calc_ssim(const YV12_BUFFER_CONFIG *source,
double aom_highbd_calc_ssimg(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, double *ssim_y,
double *ssim_u, double *ssim_v, unsigned int bd);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#ifdef __cplusplus
} // extern "C"

4
aom_dsp/subtract.c
Просмотреть файл

@ -32,7 +32,7 @@ void aom_subtract_block_c(int rows, int cols, int16_t *diff,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_subtract_block_c(int rows, int cols, int16_t *diff,
ptrdiff_t diff_stride, const uint8_t *src8,
ptrdiff_t src_stride, const uint8_t *pred8,
@ -52,4 +52,4 @@ void aom_highbd_subtract_block_c(int rows, int cols, int16_t *diff,
src += src_stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

4
aom_dsp/variance.c
Просмотреть файл

@ -257,7 +257,7 @@ void aom_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void highbd_variance64(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride, int w, int h,
uint64_t *sse, uint64_t *sum) {
@ -573,4 +573,4 @@ void aom_highbd_comp_avg_pred(uint16_t *comp_pred, const uint8_t *pred8,
ref += ref_stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

4
aom_dsp/variance.h
Просмотреть файл

@ -54,7 +54,7 @@ typedef unsigned int (*aom_subp_avg_variance_fn_t)(
const uint8_t *a_ptr, int a_stride, int xoffset, int yoffset,
const uint8_t *b_ptr, int b_stride, unsigned int *sse,
const uint8_t *second_pred);
#if CONFIG_VP10
#if CONFIG_AV1
typedef struct aom_variance_vtable {
aom_sad_fn_t sdf;
aom_sad_avg_fn_t sdaf;
@ -65,7 +65,7 @@ typedef struct aom_variance_vtable {
aom_sad_multi_fn_t sdx8f;
aom_sad_multi_d_fn_t sdx4df;
} aom_variance_fn_ptr_t;
#endif // CONFIG_VP10
#endif // CONFIG_AV1
#ifdef __cplusplus
} // extern "C"

4
aom_dsp/x86/aom_asm_stubs.c
Просмотреть файл

@ -78,7 +78,7 @@ FUN_CONV_1D(avg_vert, y_step_q4, filter_y, v, src - src_stride * 3, avg_, sse2);
FUN_CONV_2D(, sse2);
FUN_CONV_2D(avg_, sse2);
#if CONFIG_VPX_HIGHBITDEPTH && ARCH_X86_64
#if CONFIG_AOM_HIGHBITDEPTH && ARCH_X86_64
highbd_filter8_1dfunction aom_highbd_filter_block1d16_v8_sse2;
highbd_filter8_1dfunction aom_highbd_filter_block1d16_h8_sse2;
highbd_filter8_1dfunction aom_highbd_filter_block1d8_v8_sse2;
@ -159,5 +159,5 @@ HIGH_FUN_CONV_1D(avg_vert, y_step_q4, filter_y, v, src - src_stride * 3, avg_,
// int w, int h, int bd);
HIGH_FUN_CONV_2D(, sse2);
HIGH_FUN_CONV_2D(avg_, sse2);
#endif // CONFIG_VPX_HIGHBITDEPTH && ARCH_X86_64
#endif // CONFIG_AOM_HIGHBITDEPTH && ARCH_X86_64
#endif // HAVE_SSE2

2
aom_dsp/x86/aom_convolve_copy_sse2.asm
Просмотреть файл

@ -222,7 +222,7 @@ cglobal convolve_%1, 4, 7, 4+AUX_XMM_REGS, src, src_stride, \
INIT_XMM sse2
convolve_fn copy
convolve_fn avg
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
convolve_fn copy, highbd
convolve_fn avg, highbd
%endif

4
aom_dsp/x86/convolve.h
Просмотреть файл

@ -104,7 +104,7 @@ typedef void filter8_1dfunction(const uint8_t *src_ptr, ptrdiff_t src_pitch,
} \
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
typedef void highbd_filter8_1dfunction(const uint16_t *src_ptr,
const ptrdiff_t src_pitch,
@ -206,6 +206,6 @@ typedef void highbd_filter8_1dfunction(const uint16_t *src_ptr,
w, h, bd); \
} \
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // VPX_DSP_X86_CONVOLVE_H_

4
aom_dsp/x86/fwd_txfm_sse2.c
Просмотреть файл

@ -247,7 +247,7 @@ void aom_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output,
#undef FDCT32x32_HIGH_PRECISION
#undef DCT_HIGH_BIT_DEPTH
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
#define DCT_HIGH_BIT_DEPTH 1
#define FDCT4x4_2D aom_highbd_fdct4x4_sse2
#define FDCT8x8_2D aom_highbd_fdct8x8_sse2
@ -269,4 +269,4 @@ void aom_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output,
#undef FDCT32x32_2D
#undef FDCT32x32_HIGH_PRECISION
#undef DCT_HIGH_BIT_DEPTH
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

8
aom_dsp/x86/fwd_txfm_sse2.h
Просмотреть файл

@ -245,7 +245,7 @@ static INLINE int k_check_epi32_overflow_32(
}
static INLINE void store_output(const __m128i *poutput, tran_low_t *dst_ptr) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
const __m128i zero = _mm_setzero_si128();
const __m128i sign_bits = _mm_cmplt_epi16(*poutput, zero);
__m128i out0 = _mm_unpacklo_epi16(*poutput, sign_bits);
@ -254,11 +254,11 @@ static INLINE void store_output(const __m128i *poutput, tran_low_t *dst_ptr) {
_mm_store_si128((__m128i *)(dst_ptr + 4), out1);
#else
_mm_store_si128((__m128i *)(dst_ptr), *poutput);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
}
static INLINE void storeu_output(const __m128i *poutput, tran_low_t *dst_ptr) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
const __m128i zero = _mm_setzero_si128();
const __m128i sign_bits = _mm_cmplt_epi16(*poutput, zero);
__m128i out0 = _mm_unpacklo_epi16(*poutput, sign_bits);
@ -267,7 +267,7 @@ static INLINE void storeu_output(const __m128i *poutput, tran_low_t *dst_ptr) {
_mm_storeu_si128((__m128i *)(dst_ptr + 4), out1);
#else
_mm_storeu_si128((__m128i *)(dst_ptr), *poutput);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
}
static INLINE __m128i mult_round_shift(const __m128i *pin0, const __m128i *pin1,

2
aom_dsp/x86/highbd_quantize_intrin_sse2.c
Просмотреть файл

@ -15,7 +15,7 @@
#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void aom_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t count,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr,

4
aom_dsp/x86/inv_txfm_sse2.c
Просмотреть файл

@ -3473,7 +3473,7 @@ void aom_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE __m128i clamp_high_sse2(__m128i value, int bd) {
__m128i ubounded, retval;
const __m128i zero = _mm_set1_epi16(0);
@ -4035,4 +4035,4 @@ void aom_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest8,
}
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

2
aom_dsp/x86/inv_txfm_sse2.h
Просмотреть файл

@ -94,7 +94,7 @@ static INLINE void array_transpose_16x16(__m128i *res0, __m128i *res1) {
// Function to allow 8 bit optimisations to be used when profile 0 is used with
// highbitdepth enabled
static INLINE __m128i load_input_data(const tran_low_t *data) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
return octa_set_epi16(data[0], data[1], data[2], data[3], data[4], data[5],
data[6], data[7]);
#else

18
aom_dsp/x86/inv_txfm_ssse3_x86_64.asm
Просмотреть файл

@ -220,7 +220,7 @@ cglobal idct8x8_64_add, 3, 5, 13, input, output, stride
mova m12, [pw_11585x2]
lea r3, [2 * strideq]
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [inputq + 0]
packssdw m0, [inputq + 16]
mova m1, [inputq + 32]
@ -271,7 +271,7 @@ cglobal idct8x8_12_add, 3, 5, 13, input, output, stride
lea r3, [2 * strideq]
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [inputq + 0]
packssdw m0, [inputq + 16]
mova m1, [inputq + 32]
@ -793,7 +793,7 @@ idct32x32_34:
lea r4, [rsp + transposed_in]
idct32x32_34_transpose:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [r3 + 0]
packssdw m0, [r3 + 16]
mova m1, [r3 + 32 * 4]
@ -1223,7 +1223,7 @@ idct32x32_135:
mov r7, 2
idct32x32_135_transpose:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [r3 + 0]
packssdw m0, [r3 + 16]
mova m1, [r3 + 32 * 4]
@ -1261,7 +1261,7 @@ idct32x32_135_transpose:
mova [r4 + 16 * 6], m6
mova [r4 + 16 * 7], m7
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
add r3, 32
%else
add r3, 16
@ -1272,7 +1272,7 @@ idct32x32_135_transpose:
IDCT32X32_135 16*0, 16*32, 16*64, 16*96
lea stp, [stp + 16 * 8]
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea inputq, [inputq + 32 * 32]
%else
lea inputq, [inputq + 16 * 32]
@ -1687,7 +1687,7 @@ idct32x32_1024:
mov r7, 4
idct32x32_1024_transpose:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [r3 + 0]
packssdw m0, [r3 + 16]
mova m1, [r3 + 32 * 4]
@ -1725,7 +1725,7 @@ idct32x32_1024_transpose:
mova [r4 + 16 * 5], m5
mova [r4 + 16 * 6], m6
mova [r4 + 16 * 7], m7
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
add r3, 32
%else
add r3, 16
@ -1737,7 +1737,7 @@ idct32x32_1024_transpose:
IDCT32X32_1024 16*0, 16*32, 16*64, 16*96
lea stp, [stp + 16 * 8]
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea inputq, [inputq + 32 * 32]
%else
lea inputq, [inputq + 16 * 32]

2
aom_dsp/x86/inv_wht_sse2.asm
Просмотреть файл

@ -82,7 +82,7 @@ SECTION .text
INIT_XMM sse2
cglobal iwht4x4_16_add, 3, 3, 7, input, output, stride
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova m0, [inputq + 0]
packssdw m0, [inputq + 16]
mova m1, [inputq + 32]

30
aom_dsp/x86/quantize_avx_x86_64.asm
Просмотреть файл

@ -41,7 +41,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
mova m0, [zbinq] ; m0 = zbin
; Get DC and first 15 AC coeffs - in this special case, that is all.
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; coeff stored as 32bit numbers but we process them as 16 bit numbers
mova m9, [coeffq]
packssdw m9, [coeffq+16] ; m9 = c[i]
@ -73,7 +73,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
ptest m14, m14
jnz .single_nonzero
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [r1 ], ymm5
mova [r1+32], ymm5
mova [r2 ], ymm5
@ -121,7 +121,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
pand m8, m7
pand m13, m12
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; Store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m8
punpckhwd m6, m8, m6
@ -142,7 +142,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
punpckhqdq m3, m3
pmullw m13, m3 ; dqc[i] = qc[i] * q
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; Store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m8
punpckhwd m6, m8, m6
@ -226,7 +226,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
DEFINE_ARGS coeff, ncoeff, d1, qcoeff, dqcoeff, iscan, d2, d3, d4, d5, eob
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea coeffq, [ coeffq+ncoeffq*4]
lea qcoeffq, [ qcoeffq+ncoeffq*4]
lea dqcoeffq, [dqcoeffq+ncoeffq*4]
@ -239,7 +239,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
neg ncoeffq
; get DC and first 15 AC coeffs
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; coeff stored as 32bit numbers & require 16bit numbers
mova m9, [coeffq+ncoeffq*4+ 0]
packssdw m9, [coeffq+ncoeffq*4+16]
@ -261,7 +261,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
ptest m14, m14
jnz .first_nonzero
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [qcoeffq+ncoeffq*4 ], ymm5
mova [qcoeffq+ncoeffq*4+32], ymm5
mova [dqcoeffq+ncoeffq*4 ], ymm5
@ -299,7 +299,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
pand m8, m7
pand m13, m12
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m8
punpckhwd m6, m8, m6
@ -330,7 +330,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
psignw m13, m10
%endif
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m8
punpckhwd m6, m8, m6
@ -360,7 +360,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
.ac_only_loop:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; pack coeff from 32bit to 16bit array
mova m9, [coeffq+ncoeffq*4+ 0]
packssdw m9, [coeffq+ncoeffq*4+16]
@ -382,7 +382,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
ptest m14, m14
jnz .rest_nonzero
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [qcoeffq+ncoeffq*4+ 0], ymm5
mova [qcoeffq+ncoeffq*4+32], ymm5
mova [dqcoeffq+ncoeffq*4+ 0], ymm5
@ -421,7 +421,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
pand m14, m7
pand m13, m12
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m14
punpckhwd m6, m14, m6
@ -451,7 +451,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
psignw m13, m10
%endif
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pcmpgtw m6, m5, m14
punpckhwd m6, m14, m6
@ -507,7 +507,7 @@ DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
DEFINE_ARGS dqcoeff, ncoeff, qcoeff, eob
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea dqcoeffq, [dqcoeffq+ncoeffq*4]
lea qcoeffq, [ qcoeffq+ncoeffq*4]
%else
@ -519,7 +519,7 @@ DEFINE_ARGS dqcoeff, ncoeff, qcoeff, eob
pxor m7, m7
.blank_loop:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [dqcoeffq+ncoeffq*4+ 0], ymm7
mova [dqcoeffq+ncoeffq*4+32], ymm7
mova [qcoeffq+ncoeffq*4+ 0], ymm7

4
aom_dsp/x86/quantize_sse2.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "aom/aom_integer.h"
static INLINE __m128i load_coefficients(const tran_low_t* coeff_ptr) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
return _mm_setr_epi16((int16_t)coeff_ptr[0], (int16_t)coeff_ptr[1],
(int16_t)coeff_ptr[2], (int16_t)coeff_ptr[3],
(int16_t)coeff_ptr[4], (int16_t)coeff_ptr[5],
@ -28,7 +28,7 @@ static INLINE __m128i load_coefficients(const tran_low_t* coeff_ptr) {
static INLINE void store_coefficients(__m128i coeff_vals,
tran_low_t* coeff_ptr) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
__m128i one = _mm_set1_epi16(1);
__m128i coeff_vals_hi = _mm_mulhi_epi16(coeff_vals, one);
__m128i coeff_vals_lo = _mm_mullo_epi16(coeff_vals, one);

20
aom_dsp/x86/quantize_ssse3_x86_64.asm
Просмотреть файл

@ -53,7 +53,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
%endif
pxor m5, m5 ; m5 = dedicated zero
DEFINE_ARGS coeff, ncoeff, d1, qcoeff, dqcoeff, iscan, d2, d3, d4, d5, eob
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea coeffq, [ coeffq+ncoeffq*4]
lea qcoeffq, [ qcoeffq+ncoeffq*4]
lea dqcoeffq, [dqcoeffq+ncoeffq*4]
@ -66,7 +66,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
neg ncoeffq
; get DC and first 15 AC coeffs
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; coeff stored as 32bit numbers & require 16bit numbers
mova m9, [ coeffq+ncoeffq*4+ 0]
packssdw m9, [ coeffq+ncoeffq*4+16]
@ -96,7 +96,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
psignw m13, m10 ; m13 = reinsert sign
pand m8, m7
pand m13, m12
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
mova m11, m8
mova m6, m8
@ -131,7 +131,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
psignw m8, m9
psignw m13, m10
%endif
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
mova m11, m8
mova m6, m8
@ -166,7 +166,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
jz .accumulate_eob
.ac_only_loop:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; pack coeff from 32bit to 16bit array
mova m9, [ coeffq+ncoeffq*4+ 0]
packssdw m9, [ coeffq+ncoeffq*4+16]
@ -198,7 +198,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
psignw m13, m10 ; m13 = reinsert sign
pand m14, m7
pand m13, m12
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
pxor m11, m11
mova m11, m14
@ -233,7 +233,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
psignw m14, m9
psignw m13, m10
%endif
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
mova m11, m14
mova m6, m14
@ -271,7 +271,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
%ifidn %1, b_32x32
jmp .accumulate_eob
.skip_iter:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [qcoeffq+ncoeffq*4+ 0], m5
mova [qcoeffq+ncoeffq*4+16], m5
mova [qcoeffq+ncoeffq*4+32], m5
@ -310,7 +310,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
mov r2, qcoeffmp
mov r3, eobmp
DEFINE_ARGS dqcoeff, ncoeff, qcoeff, eob
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
lea dqcoeffq, [dqcoeffq+ncoeffq*4]
lea qcoeffq, [ qcoeffq+ncoeffq*4]
%else
@ -320,7 +320,7 @@ cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
neg ncoeffq
pxor m7, m7
.blank_loop:
%if CONFIG_VPX_HIGHBITDEPTH
%if CONFIG_AOM_HIGHBITDEPTH
mova [dqcoeffq+ncoeffq*4+ 0], m7
mova [dqcoeffq+ncoeffq*4+16], m7
mova [dqcoeffq+ncoeffq*4+32], m7

4
aom_mem/aom_mem.c
Просмотреть файл

@ -87,11 +87,11 @@ void aom_free(void *memblk) {
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void *aom_memset16(void *dest, int val, size_t length) {
size_t i;
uint16_t *dest16 = (uint16_t *)dest;
for (i = 0; i < length; i++) *dest16++ = val;
return dest;
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

2
aom_mem/aom_mem.h
Просмотреть файл

@ -30,7 +30,7 @@ void *aom_calloc(size_t num, size_t size);
void *aom_realloc(void *memblk, size_t size);
void aom_free(void *memblk);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void *aom_memset16(void *dest, int val, size_t length);
#endif

4
aom_ports/mem.h
Просмотреть файл

@ -44,9 +44,9 @@
#define ALIGN_POWER_OF_TWO(value, n) \
(((value) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
#define CONVERT_TO_SHORTPTR(x) ((uint16_t *)(((uintptr_t)x) << 1))
#define CONVERT_TO_BYTEPTR(x) ((uint8_t *)(((uintptr_t)x) >> 1))
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // VPX_PORTS_MEM_H_

2
aom_scale/aom_scale_rtcd.pl
Просмотреть файл

@ -22,7 +22,7 @@ add_proto qw/void aom_yv12_copy_frame/, "const struct yv12_buffer_config *src_yb
add_proto qw/void aom_yv12_copy_y/, "const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc";
if (aom_config("CONFIG_VP10") eq "yes") {
if (aom_config("CONFIG_AV1") eq "yes") {
add_proto qw/void aom_extend_frame_borders/, "struct yv12_buffer_config *ybf";
specialize qw/aom_extend_frame_borders dspr2/;

20
aom_scale/generic/yv12config.c
Просмотреть файл

@ -114,7 +114,7 @@ int aom_yv12_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
return -2;
}
#if CONFIG_VP10
#if CONFIG_AV1
// TODO(jkoleszar): Maybe replace this with struct aom_image
int aom_free_frame_buffer(YV12_BUFFER_CONFIG *ybf) {
@ -136,7 +136,7 @@ int aom_free_frame_buffer(YV12_BUFFER_CONFIG *ybf) {
int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
int ss_x, int ss_y,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int use_highbitdepth,
#endif
int border, int byte_alignment,
@ -166,21 +166,21 @@ int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
const uint64_t alpha_plane_size =
(alpha_height + 2 * alpha_border_h) * (uint64_t)alpha_stride +
byte_alignment;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
const uint64_t frame_size =
(1 + use_highbitdepth) *
(yplane_size + 2 * uvplane_size + alpha_plane_size);
#else
const uint64_t frame_size =
yplane_size + 2 * uvplane_size + alpha_plane_size;
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#else
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
const uint64_t frame_size =
(1 + use_highbitdepth) * (yplane_size + 2 * uvplane_size);
#else
const uint64_t frame_size = yplane_size + 2 * uvplane_size;
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // CONFIG_ALPHA
uint8_t *buf = NULL;
@ -251,7 +251,7 @@ int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
ybf->subsampling_y = ss_y;
buf = ybf->buffer_alloc;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (use_highbitdepth) {
// Store uint16 addresses when using 16bit framebuffers
buf = CONVERT_TO_BYTEPTR(ybf->buffer_alloc);
@ -259,7 +259,7 @@ int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
} else {
ybf->flags = 0;
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
ybf->y_buffer = (uint8_t *)yv12_align_addr(
buf + (border * y_stride) + border, aom_byte_align);
@ -288,14 +288,14 @@ int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
int aom_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
int ss_x, int ss_y,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int use_highbitdepth,
#endif
int border, int byte_alignment) {
if (ybf) {
aom_free_frame_buffer(ybf);
return aom_realloc_frame_buffer(ybf, width, height, ss_x, ss_y,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
use_highbitdepth,
#endif
border, byte_alignment, NULL, NULL, NULL);

20
aom_scale/generic/yv12extend.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
#include "aom_scale/yv12config.h"
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
#include "av1/common/common.h"
#endif
@ -60,7 +60,7 @@ static void extend_plane(uint8_t *const src, int src_stride, int width,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void extend_plane_high(uint8_t *const src8, int src_stride, int width,
int height, int extend_top, int extend_left,
int extend_bottom, int extend_right) {
@ -112,7 +112,7 @@ void aom_yv12_extend_frame_borders_c(YV12_BUFFER_CONFIG *ybf) {
assert(ybf->y_height - ybf->y_crop_height >= 0);
assert(ybf->y_width - ybf->y_crop_width >= 0);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (ybf->flags & YV12_FLAG_HIGHBITDEPTH) {
extend_plane_high(ybf->y_buffer, ybf->y_stride, ybf->y_crop_width,
ybf->y_crop_height, ybf->border, ybf->border,
@ -147,7 +147,7 @@ void aom_yv12_extend_frame_borders_c(YV12_BUFFER_CONFIG *ybf) {
uv_border + ybf->uv_width - ybf->uv_crop_width);
}
#if CONFIG_VP10
#if CONFIG_AV1
static void extend_frame(YV12_BUFFER_CONFIG *const ybf, int ext_size) {
const int c_w = ybf->uv_crop_width;
const int c_h = ybf->uv_crop_height;
@ -163,7 +163,7 @@ static void extend_frame(YV12_BUFFER_CONFIG *const ybf, int ext_size) {
assert(ybf->y_height - ybf->y_crop_height >= 0);
assert(ybf->y_width - ybf->y_crop_width >= 0);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (ybf->flags & YV12_FLAG_HIGHBITDEPTH) {
extend_plane_high(ybf->y_buffer, ybf->y_stride, ybf->y_crop_width,
ybf->y_crop_height, ext_size, ext_size,
@ -197,14 +197,14 @@ void aom_extend_frame_inner_borders_c(YV12_BUFFER_CONFIG *ybf) {
extend_frame(ybf, inner_bw);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
void memcpy_short_addr(uint8_t *dst8, const uint8_t *src8, int num) {
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
memcpy(dst, src, num * sizeof(uint16_t));
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_VP10
#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // CONFIG_AV1
// Copies the source image into the destination image and updates the
// destination's UMV borders.
@ -223,7 +223,7 @@ void aom_yv12_copy_frame_c(const YV12_BUFFER_CONFIG *src_ybc,
assert(src_ybc->y_height == dst_ybc->y_height);
#endif
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (src_ybc->flags & YV12_FLAG_HIGHBITDEPTH) {
assert(dst_ybc->flags & YV12_FLAG_HIGHBITDEPTH);
for (row = 0; row < src_ybc->y_height; ++row) {
@ -290,7 +290,7 @@ void aom_yv12_copy_y_c(const YV12_BUFFER_CONFIG *src_ybc,
const uint8_t *src = src_ybc->y_buffer;
uint8_t *dst = dst_ybc->y_buffer;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (src_ybc->flags & YV12_FLAG_HIGHBITDEPTH) {
const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
uint16_t *dst16 = CONVERT_TO_SHORTPTR(dst);

4
aom_scale/yv12config.h
Просмотреть файл

@ -75,7 +75,7 @@ int aom_yv12_de_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf);
int aom_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
int ss_x, int ss_y,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int use_highbitdepth,
#endif
int border, int byte_alignment);
@ -89,7 +89,7 @@ int aom_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
// on failure.
int aom_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf, int width, int height,
int ss_x, int ss_y,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int use_highbitdepth,
#endif
int border, int byte_alignment,

24
aomdec.c
Просмотреть файл

@ -29,7 +29,7 @@
#include "aom_ports/mem_ops.h"
#include "aom_ports/aom_timer.h"
#if CONFIG_VP10_DECODER
#if CONFIG_AV1_DECODER
#include "aom/vp8dx.h"
#endif
@ -89,7 +89,7 @@ static const arg_def_t fb_arg =
ARG_DEF(NULL, "frame-buffers", 1, "Number of frame buffers to use");
static const arg_def_t md5arg =
ARG_DEF(NULL, "md5", 0, "Compute the MD5 sum of the decoded frame");
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static const arg_def_t outbitdeptharg =
ARG_DEF(NULL, "output-bit-depth", 1, "Output bit-depth for decoded frames");
#endif
@ -100,7 +100,7 @@ static const arg_def_t *all_args[] = {
&progressarg, &limitarg, &skiparg, &postprocarg, &summaryarg, &outputfile,
&threadsarg, &frameparallelarg, &verbosearg, &scalearg, &fb_arg,
&md5arg, &error_concealment, &continuearg,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
&outbitdeptharg,
#endif
NULL
@ -110,7 +110,7 @@ static const arg_def_t *all_args[] = {
#if CONFIG_LIBYUV
static INLINE int libyuv_scale(aom_image_t *src, aom_image_t *dst,
FilterModeEnum mode) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (src->fmt == VPX_IMG_FMT_I42016) {
assert(dst->fmt == VPX_IMG_FMT_I42016);
return I420Scale_16(
@ -253,7 +253,7 @@ static void update_image_md5(const aom_image_t *img, const int planes[3],
static void write_image_file(const aom_image_t *img, const int planes[3],
FILE *file) {
int i, y;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
const int bytes_per_sample = ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
#else
const int bytes_per_sample = 1;
@ -454,7 +454,7 @@ static FILE *open_outfile(const char *name) {
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static int img_shifted_realloc_required(const aom_image_t *img,
const aom_image_t *shifted,
aom_img_fmt_t required_fmt) {
@ -487,14 +487,14 @@ static int main_loop(int argc, const char **argv_) {
int opt_yv12 = 0;
int opt_i420 = 0;
aom_codec_dec_cfg_t cfg = { 0, 0, 0 };
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
unsigned int output_bit_depth = 0;
#endif
int frames_corrupted = 0;
int dec_flags = 0;
int do_scale = 0;
aom_image_t *scaled_img = NULL;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
aom_image_t *img_shifted = NULL;
#endif
int frame_avail, got_data, flush_decoder = 0;
@ -561,7 +561,7 @@ static int main_loop(int argc, const char **argv_) {
summary = 1;
else if (arg_match(&arg, &threadsarg, argi))
cfg.threads = arg_parse_uint(&arg);
#if CONFIG_VP10_DECODER
#if CONFIG_AV1_DECODER
else if (arg_match(&arg, &frameparallelarg, argi))
frame_parallel = 1;
#endif
@ -573,7 +573,7 @@ static int main_loop(int argc, const char **argv_) {
num_external_frame_buffers = arg_parse_uint(&arg);
else if (arg_match(&arg, &continuearg, argi))
keep_going = 1;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
else if (arg_match(&arg, &outbitdeptharg, argi)) {
output_bit_depth = arg_parse_uint(&arg);
}
@ -806,7 +806,7 @@ static int main_loop(int argc, const char **argv_) {
#endif
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
// Default to codec bit depth if output bit depth not set
if (!output_bit_depth && single_file && !do_md5) {
output_bit_depth = img->bit_depth;
@ -941,7 +941,7 @@ fail:
if (input.aom_input_ctx->file_type != FILE_TYPE_WEBM) free(buf);
if (scaled_img) aom_img_free(scaled_img);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (img_shifted) aom_img_free(img_shifted);
#endif

78
aomenc.c
Просмотреть файл

@ -33,10 +33,10 @@
#include "./ivfenc.h"
#include "./tools_common.h"
#if CONFIG_VP10_ENCODER
#if CONFIG_AV1_ENCODER
#include "aom/vp8cx.h"
#endif
#if CONFIG_VP10_DECODER
#if CONFIG_AV1_DECODER
#include "aom/vp8dx.h"
#endif
@ -195,7 +195,7 @@ static const arg_def_t disable_warning_prompt =
ARG_DEF("y", "disable-warning-prompt", 0,
"Display warnings, but do not prompt user to continue.");
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static const arg_def_t test16bitinternalarg = ARG_DEF(
NULL, "test-16bit-internal", 0, "Force use of 16 bit internal buffer");
#endif
@ -268,7 +268,7 @@ static const arg_def_t *global_args[] = { &use_yv12,
&timebase,
&framerate,
&error_resilient,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
&test16bitinternalarg,
#endif
&lag_in_frames,
@ -357,7 +357,7 @@ static const arg_def_t cq_level =
static const arg_def_t max_intra_rate_pct =
ARG_DEF(NULL, "max-intra-rate", 1, "Max I-frame bitrate (pct)");
#if CONFIG_VP10_ENCODER
#if CONFIG_AV1_ENCODER
static const arg_def_t cpu_used_vp9 =
ARG_DEF(NULL, "cpu-used", 1, "CPU Used (-8..8)");
static const arg_def_t tile_cols =
@ -411,7 +411,7 @@ static const arg_def_t input_color_space =
ARG_DEF_ENUM(NULL, "color-space", 1, "The color space of input content:",
color_space_enum);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static const struct arg_enum_list bitdepth_enum[] = {
{ "8", VPX_BITS_8 }, { "10", VPX_BITS_10 }, { "12", VPX_BITS_12 }, { NULL, 0 }
};
@ -434,9 +434,9 @@ static const arg_def_t tune_content = ARG_DEF_ENUM(
NULL, "tune-content", 1, "Tune content type", tune_content_enum);
#endif
#if CONFIG_VP10_ENCODER
#if CONFIG_AV1_ENCODER
/* clang-format off */
static const arg_def_t *vp10_args[] = {
static const arg_def_t *av1_args[] = {
&cpu_used_vp9, &auto_altref, &sharpness,
&static_thresh, &tile_cols, &tile_rows,
&arnr_maxframes, &arnr_strength, &arnr_type,
@ -449,7 +449,7 @@ static const arg_def_t *vp10_args[] = {
&noise_sens, &tune_content, &input_color_space,
&min_gf_interval, &max_gf_interval, NULL
};
static const int vp10_arg_ctrl_map[] = {
static const int av1_arg_ctrl_map[] = {
VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
VP9E_SET_TILE_COLUMNS, VP9E_SET_TILE_ROWS,
@ -490,9 +490,9 @@ void usage_exit(void) {
arg_show_usage(stderr, rc_twopass_args);
fprintf(stderr, "\nKeyframe Placement Options:\n");
arg_show_usage(stderr, kf_args);
#if CONFIG_VP10_ENCODER
fprintf(stderr, "\nVP10 Specific Options:\n");
arg_show_usage(stderr, vp10_args);
#if CONFIG_AV1_ENCODER
fprintf(stderr, "\nAV1 Specific Options:\n");
arg_show_usage(stderr, av1_args);
#endif
fprintf(stderr,
"\nStream timebase (--timebase):\n"
@ -514,7 +514,7 @@ void usage_exit(void) {
#define mmin(a, b) ((a) < (b) ? (a) : (b))
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void find_mismatch_high(const aom_image_t *const img1,
const aom_image_t *const img2, int yloc[4],
int uloc[4], int vloc[4]) {
@ -711,7 +711,7 @@ static int compare_img(const aom_image_t *const img1,
match &= (img1->fmt == img2->fmt);
match &= (img1->d_w == img2->d_w);
match &= (img1->d_h == img2->d_h);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (img1->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
l_w *= 2;
c_w *= 2;
@ -737,8 +737,8 @@ static int compare_img(const aom_image_t *const img1,
}
#define NELEMENTS(x) (sizeof(x) / sizeof(x[0]))
#if CONFIG_VP10_ENCODER
#define ARG_CTRL_CNT_MAX NELEMENTS(vp10_arg_ctrl_map)
#if CONFIG_AV1_ENCODER
#define ARG_CTRL_CNT_MAX NELEMENTS(av1_arg_ctrl_map)
#endif
#if !CONFIG_WEBM_IO
@ -761,7 +761,7 @@ struct stream_config {
int arg_ctrl_cnt;
int write_webm;
int have_kf_max_dist;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
// whether to use 16bit internal buffers
int use_16bit_internal;
#endif
@ -898,7 +898,7 @@ static void parse_global_config(struct VpxEncoderConfig *global, char **argv) {
}
/* Validate global config */
if (global->passes == 0) {
#if CONFIG_VP10_ENCODER
#if CONFIG_AV1_ENCODER
// Make default VP9 passes = 2 until there is a better quality 1-pass
// encoder
if (global->codec != NULL && global->codec->name != NULL)
@ -1032,18 +1032,18 @@ static int parse_stream_params(struct VpxEncoderConfig *global,
static const int *ctrl_args_map = NULL;
struct stream_config *config = &stream->config;
int eos_mark_found = 0;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int test_16bit_internal = 0;
#endif
// Handle codec specific options
if (0) {
#if CONFIG_VP10_ENCODER
} else if (strcmp(global->codec->name, "vp10") == 0) {
#if CONFIG_AV1_ENCODER
} else if (strcmp(global->codec->name, "av1") == 0) {
// TODO(jingning): Reuse VP9 specific encoder configuration parameters.
// Consider to expand this set for VP10 encoder control.
ctrl_args = vp10_args;
ctrl_args_map = vp10_arg_ctrl_map;
// Consider to expand this set for AV1 encoder control.
ctrl_args = av1_args;
ctrl_args_map = av1_arg_ctrl_map;
#endif
}
@ -1085,7 +1085,7 @@ static int parse_stream_params(struct VpxEncoderConfig *global,
config->cfg.g_w = arg_parse_uint(&arg);
} else if (arg_match(&arg, &height, argi)) {
config->cfg.g_h = arg_parse_uint(&arg);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
} else if (arg_match(&arg, &bitdeptharg, argi)) {
config->cfg.g_bit_depth = arg_parse_enum_or_int(&arg);
} else if (arg_match(&arg, &inbitdeptharg, argi)) {
@ -1158,10 +1158,10 @@ static int parse_stream_params(struct VpxEncoderConfig *global,
config->have_kf_max_dist = 1;
} else if (arg_match(&arg, &kf_disabled, argi)) {
config->cfg.kf_mode = VPX_KF_DISABLED;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
} else if (arg_match(&arg, &test16bitinternalarg, argi)) {
if (strcmp(global->codec->name, "vp9") == 0 ||
strcmp(global->codec->name, "vp10") == 0) {
strcmp(global->codec->name, "av1") == 0) {
test_16bit_internal = 1;
}
#endif
@ -1192,9 +1192,9 @@ static int parse_stream_params(struct VpxEncoderConfig *global,
if (!match) argj++;
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (strcmp(global->codec->name, "vp9") == 0 ||
strcmp(global->codec->name, "vp10") == 0) {
strcmp(global->codec->name, "av1") == 0) {
config->use_16bit_internal =
test_16bit_internal | (config->cfg.g_profile > 1);
}
@ -1461,7 +1461,7 @@ static void initialize_encoder(struct stream_state *stream,
flags |= global->show_psnr ? VPX_CODEC_USE_PSNR : 0;
flags |= global->out_part ? VPX_CODEC_USE_OUTPUT_PARTITION : 0;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
flags |= stream->config.use_16bit_internal ? VPX_CODEC_USE_HIGHBITDEPTH : 0;
#endif
@ -1506,7 +1506,7 @@ static void encode_frame(struct stream_state *stream,
cfg->g_timebase.num / global->framerate.num;
/* Scale if necessary */
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (img) {
if ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) &&
(img->d_w != cfg->g_w || img->d_h != cfg->g_h)) {
@ -1721,7 +1721,7 @@ static void test_decode(struct stream_state *stream,
enc_img = ref_enc.img;
aom_codec_control(&stream->decoder, VP9_GET_REFERENCE, &ref_dec);
dec_img = ref_dec.img;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if ((enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) !=
(dec_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH)) {
if (enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
@ -1741,7 +1741,7 @@ static void test_decode(struct stream_state *stream,
if (!compare_img(&enc_img, &dec_img)) {
int y[4], u[4], v[4];
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
find_mismatch_high(&enc_img, &dec_img, y, u, v);
} else {
@ -1787,7 +1787,7 @@ static void print_time(const char *label, int64_t etl) {
int main(int argc, const char **argv_) {
int pass;
aom_image_t raw;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
aom_image_t raw_shift;
int allocated_raw_shift = 0;
int use_16bit_internal = 0;
@ -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 == VP10_FOURCC)
if (global.codec->fourcc == VP9_FOURCC || global.codec->fourcc == AV1_FOURCC)
input.only_i420 = 0;
for (pass = global.pass ? global.pass - 1 : 0; pass < global.passes; pass++) {
@ -1964,9 +1964,9 @@ int main(int argc, const char **argv_) {
open_output_file(stream, &global, &input.pixel_aspect_ratio));
FOREACH_STREAM(initialize_encoder(stream, &global));
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (strcmp(global.codec->name, "vp9") == 0 ||
strcmp(global.codec->name, "vp10") == 0) {
strcmp(global.codec->name, "av1") == 0) {
// Check to see if at least one stream uses 16 bit internal.
// Currently assume that the bit_depths for all streams using
// highbitdepth are the same.
@ -2018,7 +2018,7 @@ int main(int argc, const char **argv_) {
frame_avail = 0;
if (frames_in > global.skip_frames) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
aom_image_t *frame_to_encode;
if (input_shift || (use_16bit_internal && input.bit_depth == 8)) {
assert(use_16bit_internal);
@ -2174,7 +2174,7 @@ int main(int argc, const char **argv_) {
});
#endif
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (allocated_raw_shift) aom_img_free(&raw_shift);
#endif
aom_img_free(&raw);

152
av1/av1_common.mk
Просмотреть файл

@ -8,91 +8,91 @@
## be found in the AUTHORS file in the root of the source tree.
##
VP10_COMMON_SRCS-yes += av1_common.mk
VP10_COMMON_SRCS-yes += av1_iface_common.h
VP10_COMMON_SRCS-yes += common/alloccommon.c
VP10_COMMON_SRCS-yes += common/blockd.c
VP10_COMMON_SRCS-yes += common/debugmodes.c
VP10_COMMON_SRCS-yes += common/entropy.c
VP10_COMMON_SRCS-yes += common/entropymode.c
VP10_COMMON_SRCS-yes += common/entropymv.c
VP10_COMMON_SRCS-yes += common/frame_buffers.c
VP10_COMMON_SRCS-yes += common/frame_buffers.h
VP10_COMMON_SRCS-yes += common/alloccommon.h
VP10_COMMON_SRCS-yes += common/blockd.h
VP10_COMMON_SRCS-yes += common/common.h
VP10_COMMON_SRCS-yes += common/entropy.h
VP10_COMMON_SRCS-yes += common/entropymode.h
VP10_COMMON_SRCS-yes += common/entropymv.h
VP10_COMMON_SRCS-yes += common/enums.h
VP10_COMMON_SRCS-yes += common/filter.h
VP10_COMMON_SRCS-yes += common/filter.c
VP10_COMMON_SRCS-yes += common/idct.h
VP10_COMMON_SRCS-yes += common/idct.c
VP10_COMMON_SRCS-yes += common/av1_inv_txfm.h
VP10_COMMON_SRCS-yes += common/av1_inv_txfm.c
VP10_COMMON_SRCS-yes += common/loopfilter.h
VP10_COMMON_SRCS-yes += common/thread_common.h
VP10_COMMON_SRCS-yes += common/mv.h
VP10_COMMON_SRCS-yes += common/onyxc_int.h
VP10_COMMON_SRCS-yes += common/pred_common.h
VP10_COMMON_SRCS-yes += common/pred_common.c
VP10_COMMON_SRCS-yes += common/quant_common.h
VP10_COMMON_SRCS-yes += common/reconinter.h
VP10_COMMON_SRCS-yes += common/reconintra.h
VP10_COMMON_SRCS-yes += common/av1_rtcd.c
VP10_COMMON_SRCS-yes += common/av1_rtcd_defs.pl
VP10_COMMON_SRCS-yes += common/scale.h
VP10_COMMON_SRCS-yes += common/scale.c
VP10_COMMON_SRCS-yes += common/seg_common.h
VP10_COMMON_SRCS-yes += common/seg_common.c
VP10_COMMON_SRCS-yes += common/tile_common.h
VP10_COMMON_SRCS-yes += common/tile_common.c
VP10_COMMON_SRCS-yes += common/loopfilter.c
VP10_COMMON_SRCS-yes += common/thread_common.c
VP10_COMMON_SRCS-yes += common/mvref_common.c
VP10_COMMON_SRCS-yes += common/mvref_common.h
VP10_COMMON_SRCS-yes += common/quant_common.c
VP10_COMMON_SRCS-yes += common/reconinter.c
VP10_COMMON_SRCS-yes += common/reconintra.c
VP10_COMMON_SRCS-yes += common/common_data.h
VP10_COMMON_SRCS-yes += common/scan.c
VP10_COMMON_SRCS-yes += common/scan.h
VP10_COMMON_SRCS-yes += common/av1_fwd_txfm.h
VP10_COMMON_SRCS-yes += common/av1_fwd_txfm.c
VP10_COMMON_SRCS-yes += common/clpf.c
VP10_COMMON_SRCS-yes += common/clpf.h
AV1_COMMON_SRCS-yes += av1_common.mk
AV1_COMMON_SRCS-yes += av1_iface_common.h
AV1_COMMON_SRCS-yes += common/alloccommon.c
AV1_COMMON_SRCS-yes += common/blockd.c
AV1_COMMON_SRCS-yes += common/debugmodes.c
AV1_COMMON_SRCS-yes += common/entropy.c
AV1_COMMON_SRCS-yes += common/entropymode.c
AV1_COMMON_SRCS-yes += common/entropymv.c
AV1_COMMON_SRCS-yes += common/frame_buffers.c
AV1_COMMON_SRCS-yes += common/frame_buffers.h
AV1_COMMON_SRCS-yes += common/alloccommon.h
AV1_COMMON_SRCS-yes += common/blockd.h
AV1_COMMON_SRCS-yes += common/common.h
AV1_COMMON_SRCS-yes += common/entropy.h
AV1_COMMON_SRCS-yes += common/entropymode.h
AV1_COMMON_SRCS-yes += common/entropymv.h
AV1_COMMON_SRCS-yes += common/enums.h
AV1_COMMON_SRCS-yes += common/filter.h
AV1_COMMON_SRCS-yes += common/filter.c
AV1_COMMON_SRCS-yes += common/idct.h
AV1_COMMON_SRCS-yes += common/idct.c
AV1_COMMON_SRCS-yes += common/av1_inv_txfm.h
AV1_COMMON_SRCS-yes += common/av1_inv_txfm.c
AV1_COMMON_SRCS-yes += common/loopfilter.h
AV1_COMMON_SRCS-yes += common/thread_common.h
AV1_COMMON_SRCS-yes += common/mv.h
AV1_COMMON_SRCS-yes += common/onyxc_int.h
AV1_COMMON_SRCS-yes += common/pred_common.h
AV1_COMMON_SRCS-yes += common/pred_common.c
AV1_COMMON_SRCS-yes += common/quant_common.h
AV1_COMMON_SRCS-yes += common/reconinter.h
AV1_COMMON_SRCS-yes += common/reconintra.h
AV1_COMMON_SRCS-yes += common/av1_rtcd.c
AV1_COMMON_SRCS-yes += common/av1_rtcd_defs.pl
AV1_COMMON_SRCS-yes += common/scale.h
AV1_COMMON_SRCS-yes += common/scale.c
AV1_COMMON_SRCS-yes += common/seg_common.h
AV1_COMMON_SRCS-yes += common/seg_common.c
AV1_COMMON_SRCS-yes += common/tile_common.h
AV1_COMMON_SRCS-yes += common/tile_common.c
AV1_COMMON_SRCS-yes += common/loopfilter.c
AV1_COMMON_SRCS-yes += common/thread_common.c
AV1_COMMON_SRCS-yes += common/mvref_common.c
AV1_COMMON_SRCS-yes += common/mvref_common.h
AV1_COMMON_SRCS-yes += common/quant_common.c
AV1_COMMON_SRCS-yes += common/reconinter.c
AV1_COMMON_SRCS-yes += common/reconintra.c
AV1_COMMON_SRCS-yes += common/common_data.h
AV1_COMMON_SRCS-yes += common/scan.c
AV1_COMMON_SRCS-yes += common/scan.h
AV1_COMMON_SRCS-yes += common/av1_fwd_txfm.h
AV1_COMMON_SRCS-yes += common/av1_fwd_txfm.c
AV1_COMMON_SRCS-yes += common/clpf.c
AV1_COMMON_SRCS-yes += common/clpf.h
ifeq ($(CONFIG_DERING),yes)
VP10_COMMON_SRCS-yes += common/od_dering.c
VP10_COMMON_SRCS-yes += common/od_dering.h
VP10_COMMON_SRCS-yes += common/dering.c
VP10_COMMON_SRCS-yes += common/dering.h
AV1_COMMON_SRCS-yes += common/od_dering.c
AV1_COMMON_SRCS-yes += common/od_dering.h
AV1_COMMON_SRCS-yes += common/dering.c
AV1_COMMON_SRCS-yes += common/dering.h
endif
VP10_COMMON_SRCS-yes += common/odintrin.c
VP10_COMMON_SRCS-yes += common/odintrin.h
AV1_COMMON_SRCS-yes += common/odintrin.c
AV1_COMMON_SRCS-yes += common/odintrin.h
ifneq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
VP10_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans4_dspr2.c
VP10_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans8_dspr2.c
VP10_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans16_dspr2.c
ifneq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
AV1_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans4_dspr2.c
AV1_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans8_dspr2.c
AV1_COMMON_SRCS-$(HAVE_DSPR2) += common/mips/dspr2/itrans16_dspr2.c
endif
# common (msa)
VP10_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct4x4_msa.c
VP10_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct8x8_msa.c
VP10_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct16x16_msa.c
AV1_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct4x4_msa.c
AV1_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct8x8_msa.c
AV1_COMMON_SRCS-$(HAVE_MSA) += common/mips/msa/idct16x16_msa.c
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/idct_intrin_sse2.c
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_txfm_sse2.c
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_dct32x32_impl_sse2.h
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_txfm_impl_sse2.h
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/idct_intrin_sse2.c
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_txfm_sse2.c
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_dct32x32_impl_sse2.h
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_fwd_txfm_impl_sse2.h
ifneq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
VP10_COMMON_SRCS-$(HAVE_NEON) += common/arm/neon/iht4x4_add_neon.c
VP10_COMMON_SRCS-$(HAVE_NEON) += common/arm/neon/iht8x8_add_neon.c
ifneq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
AV1_COMMON_SRCS-$(HAVE_NEON) += common/arm/neon/iht4x4_add_neon.c
AV1_COMMON_SRCS-$(HAVE_NEON) += common/arm/neon/iht8x8_add_neon.c
endif
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_inv_txfm_sse2.c
VP10_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_inv_txfm_sse2.h
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_inv_txfm_sse2.c
AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/av1_inv_txfm_sse2.h
$(eval $(call rtcd_h_template,av1_rtcd,av1/common/av1_rtcd_defs.pl))

178
av1/av1_cx.mk
Просмотреть файл

@ -8,112 +8,112 @@
## be found in the AUTHORS file in the root of the source tree.
##
VP10_CX_EXPORTS += exports_enc
AV1_CX_EXPORTS += exports_enc
VP10_CX_SRCS-yes += $(VP10_COMMON_SRCS-yes)
VP10_CX_SRCS-no += $(VP10_COMMON_SRCS-no)
VP10_CX_SRCS_REMOVE-yes += $(VP10_COMMON_SRCS_REMOVE-yes)
VP10_CX_SRCS_REMOVE-no += $(VP10_COMMON_SRCS_REMOVE-no)
AV1_CX_SRCS-yes += $(AV1_COMMON_SRCS-yes)
AV1_CX_SRCS-no += $(AV1_COMMON_SRCS-no)
AV1_CX_SRCS_REMOVE-yes += $(AV1_COMMON_SRCS_REMOVE-yes)
AV1_CX_SRCS_REMOVE-no += $(AV1_COMMON_SRCS_REMOVE-no)
VP10_CX_SRCS-yes += av1_cx_iface.c
AV1_CX_SRCS-yes += av1_cx_iface.c
VP10_CX_SRCS-yes += encoder/bitstream.c
VP10_CX_SRCS-yes += encoder/context_tree.c
VP10_CX_SRCS-yes += encoder/context_tree.h
VP10_CX_SRCS-yes += encoder/cost.h
VP10_CX_SRCS-yes += encoder/cost.c
VP10_CX_SRCS-yes += encoder/dct.c
VP10_CX_SRCS-yes += encoder/encodeframe.c
VP10_CX_SRCS-yes += encoder/encodeframe.h
VP10_CX_SRCS-yes += encoder/encodemb.c
VP10_CX_SRCS-yes += encoder/encodemv.c
VP10_CX_SRCS-yes += encoder/ethread.h
VP10_CX_SRCS-yes += encoder/ethread.c
VP10_CX_SRCS-yes += encoder/extend.c
VP10_CX_SRCS-yes += encoder/firstpass.c
VP10_CX_SRCS-yes += encoder/block.h
VP10_CX_SRCS-yes += encoder/bitstream.h
VP10_CX_SRCS-yes += encoder/encodemb.h
VP10_CX_SRCS-yes += encoder/encodemv.h
VP10_CX_SRCS-yes += encoder/extend.h
VP10_CX_SRCS-yes += encoder/firstpass.h
VP10_CX_SRCS-yes += encoder/lookahead.c
VP10_CX_SRCS-yes += encoder/lookahead.h
VP10_CX_SRCS-yes += encoder/mcomp.h
VP10_CX_SRCS-yes += encoder/encoder.h
VP10_CX_SRCS-yes += encoder/quantize.h
VP10_CX_SRCS-yes += encoder/ratectrl.h
VP10_CX_SRCS-yes += encoder/rd.h
VP10_CX_SRCS-yes += encoder/rdopt.h
VP10_CX_SRCS-yes += encoder/tokenize.h
VP10_CX_SRCS-yes += encoder/treewriter.h
VP10_CX_SRCS-yes += encoder/mcomp.c
VP10_CX_SRCS-yes += encoder/encoder.c
VP10_CX_SRCS-yes += encoder/picklpf.c
VP10_CX_SRCS-yes += encoder/picklpf.h
VP10_CX_SRCS-yes += encoder/quantize.c
VP10_CX_SRCS-yes += encoder/ratectrl.c
VP10_CX_SRCS-yes += encoder/rd.c
VP10_CX_SRCS-yes += encoder/rdopt.c
VP10_CX_SRCS-yes += encoder/segmentation.c
VP10_CX_SRCS-yes += encoder/segmentation.h
VP10_CX_SRCS-yes += encoder/speed_features.c
VP10_CX_SRCS-yes += encoder/speed_features.h
VP10_CX_SRCS-yes += encoder/subexp.c
VP10_CX_SRCS-yes += encoder/subexp.h
VP10_CX_SRCS-yes += encoder/resize.c
VP10_CX_SRCS-yes += encoder/resize.h
VP10_CX_SRCS-$(CONFIG_INTERNAL_STATS) += encoder/blockiness.c
AV1_CX_SRCS-yes += encoder/bitstream.c
AV1_CX_SRCS-yes += encoder/context_tree.c
AV1_CX_SRCS-yes += encoder/context_tree.h
AV1_CX_SRCS-yes += encoder/cost.h
AV1_CX_SRCS-yes += encoder/cost.c
AV1_CX_SRCS-yes += encoder/dct.c
AV1_CX_SRCS-yes += encoder/encodeframe.c
AV1_CX_SRCS-yes += encoder/encodeframe.h
AV1_CX_SRCS-yes += encoder/encodemb.c
AV1_CX_SRCS-yes += encoder/encodemv.c
AV1_CX_SRCS-yes += encoder/ethread.h
AV1_CX_SRCS-yes += encoder/ethread.c
AV1_CX_SRCS-yes += encoder/extend.c
AV1_CX_SRCS-yes += encoder/firstpass.c
AV1_CX_SRCS-yes += encoder/block.h
AV1_CX_SRCS-yes += encoder/bitstream.h
AV1_CX_SRCS-yes += encoder/encodemb.h
AV1_CX_SRCS-yes += encoder/encodemv.h
AV1_CX_SRCS-yes += encoder/extend.h
AV1_CX_SRCS-yes += encoder/firstpass.h
AV1_CX_SRCS-yes += encoder/lookahead.c
AV1_CX_SRCS-yes += encoder/lookahead.h
AV1_CX_SRCS-yes += encoder/mcomp.h
AV1_CX_SRCS-yes += encoder/encoder.h
AV1_CX_SRCS-yes += encoder/quantize.h
AV1_CX_SRCS-yes += encoder/ratectrl.h
AV1_CX_SRCS-yes += encoder/rd.h
AV1_CX_SRCS-yes += encoder/rdopt.h
AV1_CX_SRCS-yes += encoder/tokenize.h
AV1_CX_SRCS-yes += encoder/treewriter.h
AV1_CX_SRCS-yes += encoder/mcomp.c
AV1_CX_SRCS-yes += encoder/encoder.c
AV1_CX_SRCS-yes += encoder/picklpf.c
AV1_CX_SRCS-yes += encoder/picklpf.h
AV1_CX_SRCS-yes += encoder/quantize.c
AV1_CX_SRCS-yes += encoder/ratectrl.c
AV1_CX_SRCS-yes += encoder/rd.c
AV1_CX_SRCS-yes += encoder/rdopt.c
AV1_CX_SRCS-yes += encoder/segmentation.c
AV1_CX_SRCS-yes += encoder/segmentation.h
AV1_CX_SRCS-yes += encoder/speed_features.c
AV1_CX_SRCS-yes += encoder/speed_features.h
AV1_CX_SRCS-yes += encoder/subexp.c
AV1_CX_SRCS-yes += encoder/subexp.h
AV1_CX_SRCS-yes += encoder/resize.c
AV1_CX_SRCS-yes += encoder/resize.h
AV1_CX_SRCS-$(CONFIG_INTERNAL_STATS) += encoder/blockiness.c
VP10_CX_SRCS-yes += encoder/tokenize.c
VP10_CX_SRCS-yes += encoder/treewriter.c
VP10_CX_SRCS-yes += encoder/aq_variance.c
VP10_CX_SRCS-yes += encoder/aq_variance.h
VP10_CX_SRCS-yes += encoder/aq_cyclicrefresh.c
VP10_CX_SRCS-yes += encoder/aq_cyclicrefresh.h
VP10_CX_SRCS-yes += encoder/aq_complexity.c
VP10_CX_SRCS-yes += encoder/aq_complexity.h
VP10_CX_SRCS-yes += encoder/skin_detection.c
VP10_CX_SRCS-yes += encoder/skin_detection.h
VP10_CX_SRCS-yes += encoder/temporal_filter.c
VP10_CX_SRCS-yes += encoder/temporal_filter.h
VP10_CX_SRCS-yes += encoder/mbgraph.c
VP10_CX_SRCS-yes += encoder/mbgraph.h
VP10_CX_SRCS-yes += encoder/pickdering.c
AV1_CX_SRCS-yes += encoder/tokenize.c
AV1_CX_SRCS-yes += encoder/treewriter.c
AV1_CX_SRCS-yes += encoder/aq_variance.c
AV1_CX_SRCS-yes += encoder/aq_variance.h
AV1_CX_SRCS-yes += encoder/aq_cyclicrefresh.c
AV1_CX_SRCS-yes += encoder/aq_cyclicrefresh.h
AV1_CX_SRCS-yes += encoder/aq_complexity.c
AV1_CX_SRCS-yes += encoder/aq_complexity.h
AV1_CX_SRCS-yes += encoder/skin_detection.c
AV1_CX_SRCS-yes += encoder/skin_detection.h
AV1_CX_SRCS-yes += encoder/temporal_filter.c
AV1_CX_SRCS-yes += encoder/temporal_filter.h
AV1_CX_SRCS-yes += encoder/mbgraph.c
AV1_CX_SRCS-yes += encoder/mbgraph.h
AV1_CX_SRCS-yes += encoder/pickdering.c
VP10_CX_SRCS-$(HAVE_SSE2) += encoder/x86/temporal_filter_apply_sse2.asm
VP10_CX_SRCS-$(HAVE_SSE2) += encoder/x86/quantize_sse2.c
ifeq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
VP10_CX_SRCS-$(HAVE_SSE2) += encoder/x86/highbd_block_error_intrin_sse2.c
AV1_CX_SRCS-$(HAVE_SSE2) += encoder/x86/temporal_filter_apply_sse2.asm
AV1_CX_SRCS-$(HAVE_SSE2) += encoder/x86/quantize_sse2.c
ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
AV1_CX_SRCS-$(HAVE_SSE2) += encoder/x86/highbd_block_error_intrin_sse2.c
endif
ifeq ($(CONFIG_USE_X86INC),yes)
VP10_CX_SRCS-$(HAVE_MMX) += encoder/x86/dct_mmx.asm
VP10_CX_SRCS-$(HAVE_SSE2) += encoder/x86/error_sse2.asm
AV1_CX_SRCS-$(HAVE_MMX) += encoder/x86/dct_mmx.asm
AV1_CX_SRCS-$(HAVE_SSE2) += encoder/x86/error_sse2.asm
endif
ifeq ($(ARCH_X86_64),yes)
ifeq ($(CONFIG_USE_X86INC),yes)
VP10_CX_SRCS-$(HAVE_SSSE3) += encoder/x86/quantize_ssse3_x86_64.asm
AV1_CX_SRCS-$(HAVE_SSSE3) += encoder/x86/quantize_ssse3_x86_64.asm
endif
endif
VP10_CX_SRCS-$(HAVE_SSE2) += encoder/x86/dct_sse2.c
VP10_CX_SRCS-$(HAVE_SSSE3) += encoder/x86/dct_ssse3.c
AV1_CX_SRCS-$(HAVE_SSE2) += encoder/x86/dct_sse2.c
AV1_CX_SRCS-$(HAVE_SSSE3) += encoder/x86/dct_ssse3.c
VP10_CX_SRCS-$(HAVE_AVX2) += encoder/x86/error_intrin_avx2.c
AV1_CX_SRCS-$(HAVE_AVX2) += encoder/x86/error_intrin_avx2.c
ifneq ($(CONFIG_VPX_HIGHBITDEPTH),yes)
VP10_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/dct_neon.c
VP10_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/error_neon.c
ifneq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
AV1_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/dct_neon.c
AV1_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/error_neon.c
endif
VP10_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/quantize_neon.c
AV1_CX_SRCS-$(HAVE_NEON) += encoder/arm/neon/quantize_neon.c
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/error_msa.c
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct4x4_msa.c
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct8x8_msa.c
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct16x16_msa.c
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct_msa.h
VP10_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/temporal_filter_msa.c
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/error_msa.c
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct4x4_msa.c
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct8x8_msa.c
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct16x16_msa.c
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/fdct_msa.h
AV1_CX_SRCS-$(HAVE_MSA) += encoder/mips/msa/temporal_filter_msa.c
VP10_CX_SRCS-yes := $(filter-out $(VP10_CX_SRCS_REMOVE-yes),$(VP10_CX_SRCS-yes))
AV1_CX_SRCS-yes := $(filter-out $(AV1_CX_SRCS_REMOVE-yes),$(AV1_CX_SRCS-yes))

148
av1/av1_cx_iface.c
Просмотреть файл

@ -22,7 +22,7 @@
#include "av1/encoder/firstpass.h"
#include "av1/av1_iface_common.h"
struct vp10_extracfg {
struct av1_extracfg {
int cpu_used; // available cpu percentage in 1/16
unsigned int enable_auto_alt_ref;
unsigned int noise_sensitivity;
@ -56,7 +56,7 @@ struct vp10_extracfg {
int render_height;
};
static struct vp10_extracfg default_extra_cfg = {
static struct av1_extracfg default_extra_cfg = {
0, // cpu_used
1, // enable_auto_alt_ref
0, // noise_sensitivity
@ -93,9 +93,9 @@ static struct vp10_extracfg default_extra_cfg = {
struct aom_codec_alg_priv {
aom_codec_priv_t base;
aom_codec_enc_cfg_t cfg;
struct vp10_extracfg extra_cfg;
VP10EncoderConfig oxcf;
VP10_COMP *cpi;
struct av1_extracfg extra_cfg;
AV1EncoderConfig oxcf;
AV1_COMP *cpi;
unsigned char *cx_data;
size_t cx_data_sz;
unsigned char *pending_cx_data;
@ -115,7 +115,7 @@ struct aom_codec_alg_priv {
BufferPool *buffer_pool;
};
static VPX_REFFRAME ref_frame_to_vp10_reframe(aom_ref_frame_type_t frame) {
static VPX_REFFRAME ref_frame_to_av1_reframe(aom_ref_frame_type_t frame) {
switch (frame) {
case VP8_LAST_FRAME: return VPX_LAST_FLAG;
case VP8_GOLD_FRAME: return VPX_GOLD_FLAG;
@ -165,7 +165,7 @@ static aom_codec_err_t update_error_state(
static aom_codec_err_t validate_config(aom_codec_alg_priv_t *ctx,
const aom_codec_enc_cfg_t *cfg,
const struct vp10_extracfg *extra_cfg) {
const struct av1_extracfg *extra_cfg) {
RANGE_CHECK(cfg, g_w, 1, 65535); // 16 bits available
RANGE_CHECK(cfg, g_h, 1, 65535); // 16 bits available
RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000);
@ -204,11 +204,11 @@ static aom_codec_err_t validate_config(aom_codec_alg_priv_t *ctx,
RANGE_CHECK(cfg, rc_scaled_height, 0, cfg->g_h);
}
// Spatial/temporal scalability are not yet supported in VP10.
// Spatial/temporal scalability are not yet supported in AV1.
// Only accept the default value for range checking.
RANGE_CHECK(cfg, ss_number_layers, 1, 1);
RANGE_CHECK(cfg, ts_number_layers, 1, 1);
// VP10 does not support a lower bound on the keyframe interval in
// AV1 does not support a lower bound on the keyframe interval in
// automatic keyframe placement mode.
if (cfg->kf_mode != VPX_KF_DISABLED && cfg->kf_min_dist != cfg->kf_max_dist &&
cfg->kf_min_dist > 0)
@ -229,9 +229,9 @@ static aom_codec_err_t validate_config(aom_codec_alg_priv_t *ctx,
RANGE_CHECK(cfg, g_input_bit_depth, 8, 12);
RANGE_CHECK(extra_cfg, content, VPX_CONTENT_DEFAULT, VPX_CONTENT_INVALID - 1);
// TODO(yaowu): remove this when ssim tuning is implemented for vp10
// TODO(yaowu): remove this when ssim tuning is implemented for av1
if (extra_cfg->tuning == VPX_TUNE_SSIM)
ERROR("Option --tune=ssim is not currently supported in VP10.");
ERROR("Option --tune=ssim is not currently supported in AV1.");
if (cfg->g_pass == VPX_RC_LAST_PASS) {
const size_t packet_sz = sizeof(FIRSTPASS_STATS);
@ -254,7 +254,7 @@ static aom_codec_err_t validate_config(aom_codec_alg_priv_t *ctx,
ERROR("rc_twopass_stats_in missing EOS stats packet");
}
#if !CONFIG_VPX_HIGHBITDEPTH
#if !CONFIG_AOM_HIGHBITDEPTH
if (cfg->g_profile > (unsigned int)PROFILE_1) {
ERROR("Profile > 1 not supported in this build configuration");
}
@ -330,8 +330,8 @@ static int get_image_bps(const aom_image_t *img) {
}
static aom_codec_err_t set_encoder_config(
VP10EncoderConfig *oxcf, const aom_codec_enc_cfg_t *cfg,
const struct vp10_extracfg *extra_cfg) {
AV1EncoderConfig *oxcf, const aom_codec_enc_cfg_t *cfg,
const struct av1_extracfg *extra_cfg) {
const int is_vbr = cfg->rc_end_usage == VPX_VBR;
oxcf->profile = cfg->g_profile;
oxcf->max_threads = (int)cfg->g_threads;
@ -362,10 +362,10 @@ static aom_codec_err_t set_encoder_config(
oxcf->gf_cbr_boost_pct = extra_cfg->gf_cbr_boost_pct;
oxcf->best_allowed_q =
extra_cfg->lossless ? 0 : vp10_quantizer_to_qindex(cfg->rc_min_quantizer);
extra_cfg->lossless ? 0 : av1_quantizer_to_qindex(cfg->rc_min_quantizer);
oxcf->worst_allowed_q =
extra_cfg->lossless ? 0 : vp10_quantizer_to_qindex(cfg->rc_max_quantizer);
oxcf->cq_level = vp10_quantizer_to_qindex(extra_cfg->cq_level);
extra_cfg->lossless ? 0 : av1_quantizer_to_qindex(cfg->rc_max_quantizer);
oxcf->cq_level = av1_quantizer_to_qindex(extra_cfg->cq_level);
oxcf->fixed_q = -1;
#if CONFIG_AOM_QM
@ -438,7 +438,7 @@ static aom_codec_err_t set_encoder_config(
oxcf->frame_periodic_boost = extra_cfg->frame_periodic_boost;
/*
printf("Current VP10 Settings: \n");
printf("Current AV1 Settings: \n");
printf("target_bandwidth: %d\n", oxcf->target_bandwidth);
printf("noise_sensitivity: %d\n", oxcf->noise_sensitivity);
printf("sharpness: %d\n", oxcf->sharpness);
@ -500,7 +500,7 @@ static aom_codec_err_t encoder_set_config(aom_codec_alg_priv_t *ctx,
set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg);
// On profile change, request a key frame
force_key |= ctx->cpi->common.profile != ctx->oxcf.profile;
vp10_change_config(ctx->cpi, &ctx->oxcf);
av1_change_config(ctx->cpi, &ctx->oxcf);
}
if (force_key) ctx->next_frame_flags |= VPX_EFLAG_FORCE_KF;
@ -512,7 +512,7 @@ static aom_codec_err_t ctrl_get_quantizer(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return VPX_CODEC_INVALID_PARAM;
*arg = vp10_get_quantizer(ctx->cpi);
*arg = av1_get_quantizer(ctx->cpi);
return VPX_CODEC_OK;
}
@ -520,80 +520,80 @@ static aom_codec_err_t ctrl_get_quantizer64(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return VPX_CODEC_INVALID_PARAM;
*arg = vp10_qindex_to_quantizer(vp10_get_quantizer(ctx->cpi));
*arg = av1_qindex_to_quantizer(av1_get_quantizer(ctx->cpi));
return VPX_CODEC_OK;
}
static aom_codec_err_t update_extra_cfg(aom_codec_alg_priv_t *ctx,
const struct vp10_extracfg *extra_cfg) {
const struct av1_extracfg *extra_cfg) {
const aom_codec_err_t res = validate_config(ctx, &ctx->cfg, extra_cfg);
if (res == VPX_CODEC_OK) {
ctx->extra_cfg = *extra_cfg;
set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg);
vp10_change_config(ctx->cpi, &ctx->oxcf);
av1_change_config(ctx->cpi, &ctx->oxcf);
}
return res;
}
static aom_codec_err_t ctrl_set_cpuused(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.cpu_used = CAST(VP8E_SET_CPUUSED, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_enable_auto_alt_ref(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.enable_auto_alt_ref = CAST(VP8E_SET_ENABLEAUTOALTREF, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_noise_sensitivity(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.noise_sensitivity = CAST(VP9E_SET_NOISE_SENSITIVITY, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_sharpness(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.sharpness = CAST(VP8E_SET_SHARPNESS, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_static_thresh(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.static_thresh = CAST(VP8E_SET_STATIC_THRESHOLD, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_tile_columns(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.tile_columns = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.tile_rows = CAST(VP9E_SET_TILE_ROWS, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_arnr_max_frames(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.arnr_max_frames = CAST(VP8E_SET_ARNR_MAXFRAMES, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_arnr_strength(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.arnr_strength = CAST(VP8E_SET_ARNR_STRENGTH, args);
return update_extra_cfg(ctx, &extra_cfg);
}
@ -607,21 +607,21 @@ static aom_codec_err_t ctrl_set_arnr_type(aom_codec_alg_priv_t *ctx,
static aom_codec_err_t ctrl_set_tuning(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.tuning = CAST(VP8E_SET_TUNING, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_cq_level(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.cq_level = CAST(VP8E_SET_CQ_LEVEL, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_rc_max_intra_bitrate_pct(
aom_codec_alg_priv_t *ctx, va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.rc_max_intra_bitrate_pct =
CAST(VP8E_SET_MAX_INTRA_BITRATE_PCT, args);
return update_extra_cfg(ctx, &extra_cfg);
@ -629,7 +629,7 @@ static aom_codec_err_t ctrl_set_rc_max_intra_bitrate_pct(
static aom_codec_err_t ctrl_set_rc_max_inter_bitrate_pct(
aom_codec_alg_priv_t *ctx, va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.rc_max_inter_bitrate_pct =
CAST(VP8E_SET_MAX_INTER_BITRATE_PCT, args);
return update_extra_cfg(ctx, &extra_cfg);
@ -637,14 +637,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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.gf_cbr_boost_pct = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.lossless = CAST(VP9E_SET_LOSSLESS, args);
return update_extra_cfg(ctx, &extra_cfg);
}
@ -652,21 +652,21 @@ static aom_codec_err_t ctrl_set_lossless(aom_codec_alg_priv_t *ctx,
#if CONFIG_AOM_QM
static aom_codec_err_t ctrl_set_enable_qm(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.enable_qm = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.qm_min = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.qm_max = CAST(VP9E_SET_QM_MAX, args);
return update_extra_cfg(ctx, &extra_cfg);
}
@ -674,7 +674,7 @@ static aom_codec_err_t ctrl_set_qm_max(aom_codec_alg_priv_t *ctx,
static aom_codec_err_t ctrl_set_frame_parallel_decoding_mode(
aom_codec_alg_priv_t *ctx, va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.frame_parallel_decoding_mode =
CAST(VP9E_SET_FRAME_PARALLEL_DECODING, args);
return update_extra_cfg(ctx, &extra_cfg);
@ -682,28 +682,28 @@ static aom_codec_err_t ctrl_set_frame_parallel_decoding_mode(
static aom_codec_err_t ctrl_set_aq_mode(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.aq_mode = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.min_gf_interval = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.max_gf_interval = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.frame_periodic_boost = CAST(VP9E_SET_FRAME_PERIODIC_BOOST, args);
return update_extra_cfg(ctx, &extra_cfg);
}
@ -736,17 +736,17 @@ static aom_codec_err_t encoder_init(aom_codec_ctx_t *ctx,
}
priv->extra_cfg = default_extra_cfg;
once(vp10_initialize_enc);
once(av1_initialize_enc);
res = validate_config(priv, &priv->cfg, &priv->extra_cfg);
if (res == VPX_CODEC_OK) {
set_encoder_config(&priv->oxcf, &priv->cfg, &priv->extra_cfg);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
priv->oxcf.use_highbitdepth =
(ctx->init_flags & VPX_CODEC_USE_HIGHBITDEPTH) ? 1 : 0;
#endif
priv->cpi = vp10_create_compressor(&priv->oxcf, priv->buffer_pool);
priv->cpi = av1_create_compressor(&priv->oxcf, priv->buffer_pool);
if (priv->cpi == NULL)
res = VPX_CODEC_MEM_ERROR;
else
@ -759,7 +759,7 @@ static aom_codec_err_t encoder_init(aom_codec_ctx_t *ctx,
static aom_codec_err_t encoder_destroy(aom_codec_alg_priv_t *ctx) {
free(ctx->cx_data);
vp10_remove_compressor(ctx->cpi);
av1_remove_compressor(ctx->cpi);
#if CONFIG_MULTITHREAD
pthread_mutex_destroy(&ctx->buffer_pool->pool_mutex);
#endif
@ -796,7 +796,7 @@ static void pick_quickcompress_mode(aom_codec_alg_priv_t *ctx,
if (ctx->oxcf.mode != new_mode) {
ctx->oxcf.mode = new_mode;
vp10_change_config(ctx->cpi, &ctx->oxcf);
av1_change_config(ctx->cpi, &ctx->oxcf);
}
}
@ -875,7 +875,7 @@ static int write_superframe_index(aom_codec_alg_priv_t *ctx) {
return index_sz;
}
// vp10 uses 10,000,000 ticks/second as time stamp
// av1 uses 10,000,000 ticks/second as time stamp
#define TICKS_PER_SEC 10000000LL
static int64_t timebase_units_to_ticks(const aom_rational_t *timebase,
@ -889,7 +889,7 @@ static int64_t ticks_to_timebase_units(const aom_rational_t *timebase,
return (n * timebase->den + round) / timebase->num / TICKS_PER_SEC;
}
static aom_codec_frame_flags_t get_frame_pkt_flags(const VP10_COMP *cpi,
static aom_codec_frame_flags_t get_frame_pkt_flags(const AV1_COMP *cpi,
unsigned int lib_flags) {
aom_codec_frame_flags_t flags = lib_flags << 16;
@ -907,7 +907,7 @@ static aom_codec_err_t encoder_encode(aom_codec_alg_priv_t *ctx,
aom_enc_frame_flags_t flags,
unsigned long deadline) {
aom_codec_err_t res = VPX_CODEC_OK;
VP10_COMP *const cpi = ctx->cpi;
AV1_COMP *const cpi = ctx->cpi;
const aom_rational_t *const timebase = &ctx->cfg.g_timebase;
size_t data_sz;
@ -942,7 +942,7 @@ static aom_codec_err_t encoder_encode(aom_codec_alg_priv_t *ctx,
return VPX_CODEC_INVALID_PARAM;
}
vp10_apply_encoding_flags(cpi, flags);
av1_apply_encoding_flags(cpi, flags);
// Handle fixed keyframe intervals
if (ctx->cfg.kf_mode == VPX_KF_AUTO &&
@ -971,7 +971,7 @@ static aom_codec_err_t encoder_encode(aom_codec_alg_priv_t *ctx,
// Store the original flags in to the frame buffer. Will extract the
// key frame flag when we actually encode this frame.
if (vp10_receive_raw_frame(cpi, flags | ctx->next_frame_flags, &sd,
if (av1_receive_raw_frame(cpi, flags | ctx->next_frame_flags, &sd,
dst_time_stamp, dst_end_time_stamp)) {
res = update_error_state(ctx, &cpi->common.error);
}
@ -998,7 +998,7 @@ static aom_codec_err_t encoder_encode(aom_codec_alg_priv_t *ctx,
}
while (cx_data_sz >= ctx->cx_data_sz / 2 &&
-1 != vp10_get_compressed_data(cpi, &lib_flags, &size, cx_data,
-1 != av1_get_compressed_data(cpi, &lib_flags, &size, cx_data,
&dst_time_stamp, &dst_end_time_stamp,
!img)) {
if (size) {
@ -1094,8 +1094,8 @@ static aom_codec_err_t ctrl_set_reference(aom_codec_alg_priv_t *ctx,
YV12_BUFFER_CONFIG sd;
image2yuvconfig(&frame->img, &sd);
vp10_set_reference_enc(ctx->cpi,
ref_frame_to_vp10_reframe(frame->frame_type), &sd);
av1_set_reference_enc(ctx->cpi,
ref_frame_to_av1_reframe(frame->frame_type), &sd);
return VPX_CODEC_OK;
} else {
return VPX_CODEC_INVALID_PARAM;
@ -1110,8 +1110,8 @@ static aom_codec_err_t ctrl_copy_reference(aom_codec_alg_priv_t *ctx,
YV12_BUFFER_CONFIG sd;
image2yuvconfig(&frame->img, &sd);
vp10_copy_reference_enc(ctx->cpi,
ref_frame_to_vp10_reframe(frame->frame_type), &sd);
av1_copy_reference_enc(ctx->cpi,
ref_frame_to_av1_reframe(frame->frame_type), &sd);
return VPX_CODEC_OK;
} else {
return VPX_CODEC_INVALID_PARAM;
@ -1143,7 +1143,7 @@ static aom_codec_err_t ctrl_set_previewpp(aom_codec_alg_priv_t *ctx,
static aom_image_t *encoder_get_preview(aom_codec_alg_priv_t *ctx) {
YV12_BUFFER_CONFIG sd;
if (vp10_get_preview_raw_frame(ctx->cpi, &sd) == 0) {
if (av1_get_preview_raw_frame(ctx->cpi, &sd) == 0) {
yuvconfig2image(&ctx->preview_img, &sd, NULL);
return &ctx->preview_img;
} else {
@ -1156,7 +1156,7 @@ static aom_codec_err_t ctrl_set_roi_map(aom_codec_alg_priv_t *ctx,
(void)ctx;
(void)args;
// TODO(yaowu): Need to re-implement and test for VP10.
// TODO(yaowu): Need to re-implement and test for AV1.
return VPX_CODEC_INVALID_PARAM;
}
@ -1165,7 +1165,7 @@ static aom_codec_err_t ctrl_set_active_map(aom_codec_alg_priv_t *ctx,
aom_active_map_t *const map = va_arg(args, aom_active_map_t *);
if (map) {
if (!vp10_set_active_map(ctx->cpi, map->active_map, (int)map->rows,
if (!av1_set_active_map(ctx->cpi, map->active_map, (int)map->rows,
(int)map->cols))
return VPX_CODEC_OK;
else
@ -1180,7 +1180,7 @@ static aom_codec_err_t ctrl_get_active_map(aom_codec_alg_priv_t *ctx,
aom_active_map_t *const map = va_arg(args, aom_active_map_t *);
if (map) {
if (!vp10_get_active_map(ctx->cpi, map->active_map, (int)map->rows,
if (!av1_get_active_map(ctx->cpi, map->active_map, (int)map->rows,
(int)map->cols))
return VPX_CODEC_OK;
else
@ -1196,7 +1196,7 @@ static aom_codec_err_t ctrl_set_scale_mode(aom_codec_alg_priv_t *ctx,
if (mode) {
const int res =
vp10_set_internal_size(ctx->cpi, (VPX_SCALING)mode->h_scaling_mode,
av1_set_internal_size(ctx->cpi, (VPX_SCALING)mode->h_scaling_mode,
(VPX_SCALING)mode->v_scaling_mode);
return (res == 0) ? VPX_CODEC_OK : VPX_CODEC_INVALID_PARAM;
} else {
@ -1216,28 +1216,28 @@ 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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.content = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.color_space = CAST(VP9E_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 vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
extra_cfg.color_range = CAST(VP9E_SET_COLOR_RANGE, args);
return update_extra_cfg(ctx, &extra_cfg);
}
static aom_codec_err_t ctrl_set_render_size(aom_codec_alg_priv_t *ctx,
va_list args) {
struct vp10_extracfg extra_cfg = ctx->extra_cfg;
struct av1_extracfg extra_cfg = ctx->extra_cfg;
int *const render_size = va_arg(args, int *);
extra_cfg.render_width = render_size[0];
extra_cfg.render_height = render_size[1];
@ -1345,7 +1345,7 @@ static aom_codec_enc_cfg_map_t encoder_usage_cfg_map[] = {
9999, // kf_max_dist
// TODO(yunqingwang): Spatial/temporal scalability are not supported
// in VP10. The following 10 parameters are not used, which should
// in AV1. The following 10 parameters are not used, which should
// be removed later.
1, // ss_number_layers
{ 0 },
@ -1363,10 +1363,10 @@ static aom_codec_enc_cfg_map_t encoder_usage_cfg_map[] = {
#ifndef VERSION_STRING
#define VERSION_STRING
#endif
CODEC_INTERFACE(aom_codec_vp10_cx) = {
"WebM Project VP10 Encoder" VERSION_STRING,
CODEC_INTERFACE(aom_codec_av1_cx) = {
"WebM Project AV1 Encoder" VERSION_STRING,
VPX_CODEC_INTERNAL_ABI_VERSION,
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
VPX_CODEC_CAP_HIGHBITDEPTH |
#endif
VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR, // aom_codec_caps_t

38
av1/av1_dx.mk
Просмотреть файл

@ -8,26 +8,26 @@
## be found in the AUTHORS file in the root of the source tree.
##
VP10_DX_EXPORTS += exports_dec
AV1_DX_EXPORTS += exports_dec
VP10_DX_SRCS-yes += $(VP10_COMMON_SRCS-yes)
VP10_DX_SRCS-no += $(VP10_COMMON_SRCS-no)
VP10_DX_SRCS_REMOVE-yes += $(VP10_COMMON_SRCS_REMOVE-yes)
VP10_DX_SRCS_REMOVE-no += $(VP10_COMMON_SRCS_REMOVE-no)
AV1_DX_SRCS-yes += $(AV1_COMMON_SRCS-yes)
AV1_DX_SRCS-no += $(AV1_COMMON_SRCS-no)
AV1_DX_SRCS_REMOVE-yes += $(AV1_COMMON_SRCS_REMOVE-yes)
AV1_DX_SRCS_REMOVE-no += $(AV1_COMMON_SRCS_REMOVE-no)
VP10_DX_SRCS-yes += av1_dx_iface.c
AV1_DX_SRCS-yes += av1_dx_iface.c
VP10_DX_SRCS-yes += decoder/decodemv.c
VP10_DX_SRCS-yes += decoder/decodeframe.c
VP10_DX_SRCS-yes += decoder/decodeframe.h
VP10_DX_SRCS-yes += decoder/detokenize.c
VP10_DX_SRCS-yes += decoder/decodemv.h
VP10_DX_SRCS-yes += decoder/detokenize.h
VP10_DX_SRCS-yes += decoder/dthread.c
VP10_DX_SRCS-yes += decoder/dthread.h
VP10_DX_SRCS-yes += decoder/decoder.c
VP10_DX_SRCS-yes += decoder/decoder.h
VP10_DX_SRCS-yes += decoder/dsubexp.c
VP10_DX_SRCS-yes += decoder/dsubexp.h
AV1_DX_SRCS-yes += decoder/decodemv.c
AV1_DX_SRCS-yes += decoder/decodeframe.c
AV1_DX_SRCS-yes += decoder/decodeframe.h
AV1_DX_SRCS-yes += decoder/detokenize.c
AV1_DX_SRCS-yes += decoder/decodemv.h
AV1_DX_SRCS-yes += decoder/detokenize.h
AV1_DX_SRCS-yes += decoder/dthread.c
AV1_DX_SRCS-yes += decoder/dthread.h
AV1_DX_SRCS-yes += decoder/decoder.c
AV1_DX_SRCS-yes += decoder/decoder.h
AV1_DX_SRCS-yes += decoder/dsubexp.c
AV1_DX_SRCS-yes += decoder/dsubexp.h
VP10_DX_SRCS-yes := $(filter-out $(VP10_DX_SRCS_REMOVE-yes),$(VP10_DX_SRCS-yes))
AV1_DX_SRCS-yes := $(filter-out $(AV1_DX_SRCS_REMOVE-yes),$(AV1_DX_SRCS-yes))

74
av1/av1_dx_iface.c
Просмотреть файл

@ -30,7 +30,7 @@
#include "av1/av1_iface_common.h"
typedef aom_codec_stream_info_t vp10_stream_info_t;
typedef aom_codec_stream_info_t av1_stream_info_t;
// This limit is due to framebuffer numbers.
// TODO(hkuang): Remove this limit after implementing ondemand framebuffers.
@ -44,7 +44,7 @@ typedef struct cache_frame {
struct aom_codec_alg_priv {
aom_codec_priv_t base;
aom_codec_dec_cfg_t cfg;
vp10_stream_info_t si;
av1_stream_info_t si;
int postproc_cfg_set;
vp8_postproc_cfg_t postproc_cfg;
aom_decrypt_cb decrypt_cb;
@ -73,7 +73,7 @@ struct aom_codec_alg_priv {
// BufferPool that holds all reference frames. Shared by all the FrameWorkers.
BufferPool *buffer_pool;
// External frame buffer info to save for VP10 common.
// External frame buffer info to save for AV1 common.
void *ext_priv; // Private data associated with the external frame buffers.
aom_get_frame_buffer_cb_fn_t get_ext_fb_cb;
aom_release_frame_buffer_cb_fn_t release_ext_fb_cb;
@ -118,8 +118,8 @@ static aom_codec_err_t decoder_destroy(aom_codec_alg_priv_t *ctx) {
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
aom_get_worker_interface()->end(worker);
vp10_remove_common(&frame_worker_data->pbi->common);
vp10_decoder_remove(frame_worker_data->pbi);
av1_remove_common(&frame_worker_data->pbi->common);
av1_decoder_remove(frame_worker_data->pbi);
aom_free(frame_worker_data->scratch_buffer);
#if CONFIG_MULTITHREAD
pthread_mutex_destroy(&frame_worker_data->stats_mutex);
@ -133,8 +133,8 @@ static aom_codec_err_t decoder_destroy(aom_codec_alg_priv_t *ctx) {
}
if (ctx->buffer_pool) {
vp10_free_ref_frame_buffers(ctx->buffer_pool);
vp10_free_internal_frame_buffers(&ctx->buffer_pool->int_frame_buffers);
av1_free_ref_frame_buffers(ctx->buffer_pool);
av1_free_internal_frame_buffers(&ctx->buffer_pool->int_frame_buffers);
}
aom_free(ctx->frame_workers);
@ -187,7 +187,7 @@ static aom_codec_err_t decoder_peek_si_internal(
int error_resilient;
struct aom_read_bit_buffer rb = { data, data + data_sz, 0, NULL, NULL };
const int frame_marker = aom_rb_read_literal(&rb, 2);
const BITSTREAM_PROFILE profile = vp10_read_profile(&rb);
const BITSTREAM_PROFILE profile = av1_read_profile(&rb);
if (frame_marker != VPX_FRAME_MARKER) return VPX_CODEC_UNSUP_BITSTREAM;
@ -208,24 +208,24 @@ static aom_codec_err_t decoder_peek_si_internal(
error_resilient = aom_rb_read_bit(&rb);
if (si->is_kf) {
if (!vp10_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM;
if (!av1_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM;
if (!parse_bitdepth_colorspace_sampling(profile, &rb))
return VPX_CODEC_UNSUP_BITSTREAM;
vp10_read_frame_size(&rb, (int *)&si->w, (int *)&si->h);
av1_read_frame_size(&rb, (int *)&si->w, (int *)&si->h);
} else {
intra_only_flag = show_frame ? 0 : aom_rb_read_bit(&rb);
rb.bit_offset += error_resilient ? 0 : 2; // reset_frame_context
if (intra_only_flag) {
if (!vp10_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM;
if (!av1_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM;
if (profile > PROFILE_0) {
if (!parse_bitdepth_colorspace_sampling(profile, &rb))
return VPX_CODEC_UNSUP_BITSTREAM;
}
rb.bit_offset += REF_FRAMES; // refresh_frame_flags
vp10_read_frame_size(&rb, (int *)&si->w, (int *)&si->h);
av1_read_frame_size(&rb, (int *)&si->w, (int *)&si->h);
}
}
}
@ -241,8 +241,8 @@ static aom_codec_err_t decoder_peek_si(const uint8_t *data,
static aom_codec_err_t decoder_get_si(aom_codec_alg_priv_t *ctx,
aom_codec_stream_info_t *si) {
const size_t sz = (si->sz >= sizeof(vp10_stream_info_t))
? sizeof(vp10_stream_info_t)
const size_t sz = (si->sz >= sizeof(av1_stream_info_t))
? sizeof(av1_stream_info_t)
: sizeof(aom_codec_stream_info_t);
memcpy(si, &ctx->si, sz);
si->sz = (unsigned int)sz;
@ -269,7 +269,7 @@ static void init_buffer_callbacks(aom_codec_alg_priv_t *ctx) {
for (i = 0; i < ctx->num_frame_workers; ++i) {
VPxWorker *const worker = &ctx->frame_workers[i];
FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1;
VP10_COMMON *const cm = &frame_worker_data->pbi->common;
AV1_COMMON *const cm = &frame_worker_data->pbi->common;
BufferPool *const pool = cm->buffer_pool;
cm->new_fb_idx = INVALID_IDX;
@ -281,10 +281,10 @@ static void init_buffer_callbacks(aom_codec_alg_priv_t *ctx) {
pool->release_fb_cb = ctx->release_ext_fb_cb;
pool->cb_priv = ctx->ext_priv;
} else {
pool->get_fb_cb = vp10_get_frame_buffer;
pool->release_fb_cb = vp10_release_frame_buffer;
pool->get_fb_cb = av1_get_frame_buffer;
pool->release_fb_cb = av1_release_frame_buffer;
if (vp10_alloc_internal_frame_buffers(&pool->int_frame_buffers))
if (av1_alloc_internal_frame_buffers(&pool->int_frame_buffers))
aom_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to initialize internal frame buffers");
@ -304,7 +304,7 @@ static int frame_worker_hook(void *arg1, void *arg2) {
const uint8_t *data = frame_worker_data->data;
(void)arg2;
frame_worker_data->result = vp10_receive_compressed_data(
frame_worker_data->result = av1_receive_compressed_data(
frame_worker_data->pbi, frame_worker_data->data_size, &data);
frame_worker_data->data_end = data;
@ -316,14 +316,14 @@ static int frame_worker_hook(void *arg1, void *arg2) {
VPxWorker *const worker = frame_worker_data->pbi->frame_worker_owner;
BufferPool *const pool = frame_worker_data->pbi->common.buffer_pool;
// Signal all the other threads that are waiting for this frame.
vp10_frameworker_lock_stats(worker);
av1_frameworker_lock_stats(worker);
frame_worker_data->frame_context_ready = 1;
lock_buffer_pool(pool);
frame_worker_data->pbi->cur_buf->buf.corrupted = 1;
unlock_buffer_pool(pool);
frame_worker_data->pbi->need_resync = 1;
vp10_frameworker_signal_stats(worker);
vp10_frameworker_unlock_stats(worker);
av1_frameworker_signal_stats(worker);
av1_frameworker_unlock_stats(worker);
return 0;
}
} else if (frame_worker_data->result != 0) {
@ -380,7 +380,7 @@ static aom_codec_err_t init_decoder(aom_codec_alg_priv_t *ctx) {
return VPX_CODEC_MEM_ERROR;
}
frame_worker_data = (FrameWorkerData *)worker->data1;
frame_worker_data->pbi = vp10_decoder_create(ctx->buffer_pool);
frame_worker_data->pbi = av1_decoder_create(ctx->buffer_pool);
if (frame_worker_data->pbi == NULL) {
set_error_detail(ctx, "Failed to allocate frame_worker_data");
return VPX_CODEC_MEM_ERROR;
@ -428,7 +428,7 @@ static aom_codec_err_t init_decoder(aom_codec_alg_priv_t *ctx) {
}
static INLINE void check_resync(aom_codec_alg_priv_t *const ctx,
const VP10Decoder *const pbi) {
const AV1Decoder *const pbi) {
// Clear resync flag if worker got a key frame or intra only frame.
if (ctx->need_resync == 1 && pbi->need_resync == 0 &&
(pbi->common.intra_only || pbi->common.frame_type == KEY_FRAME))
@ -482,7 +482,7 @@ static aom_codec_err_t decode_one(aom_codec_alg_priv_t *ctx,
FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1;
// Copy context from last worker thread to next worker thread.
if (ctx->next_submit_worker_id != ctx->last_submit_worker_id)
vp10_frameworker_copy_context(
av1_frameworker_copy_context(
&ctx->frame_workers[ctx->next_submit_worker_id],
&ctx->frame_workers[ctx->last_submit_worker_id]);
@ -537,8 +537,8 @@ static void wait_worker_and_cache_frame(aom_codec_alg_priv_t *ctx) {
check_resync(ctx, frame_worker_data->pbi);
if (vp10_get_raw_frame(frame_worker_data->pbi, &sd) == 0) {
VP10_COMMON *const cm = &frame_worker_data->pbi->common;
if (av1_get_raw_frame(frame_worker_data->pbi, &sd) == 0) {
AV1_COMMON *const cm = &frame_worker_data->pbi->common;
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
ctx->frame_cache[ctx->frame_cache_write].fb_idx = cm->new_fb_idx;
yuvconfig2image(&ctx->frame_cache[ctx->frame_cache_write].img, &sd,
@ -573,7 +573,7 @@ static aom_codec_err_t decoder_decode(aom_codec_alg_priv_t *ctx,
if (res != VPX_CODEC_OK) return res;
}
res = vp10_parse_superframe_index(data, data_sz, frame_sizes, &frame_count,
res = av1_parse_superframe_index(data, data_sz, frame_sizes, &frame_count,
ctx->decrypt_cb, ctx->decrypt_state);
if (res != VPX_CODEC_OK) return res;
@ -721,8 +721,8 @@ static aom_image_t *decoder_get_frame(aom_codec_alg_priv_t *ctx,
frame_worker_data->received_frame = 0;
check_resync(ctx, frame_worker_data->pbi);
}
if (vp10_get_raw_frame(frame_worker_data->pbi, &sd) == 0) {
VP10_COMMON *const cm = &frame_worker_data->pbi->common;
if (av1_get_raw_frame(frame_worker_data->pbi, &sd) == 0) {
AV1_COMMON *const cm = &frame_worker_data->pbi->common;
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
release_last_output_frame(ctx);
ctx->last_show_frame = frame_worker_data->pbi->common.new_fb_idx;
@ -777,7 +777,7 @@ static aom_codec_err_t ctrl_set_reference(aom_codec_alg_priv_t *ctx,
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1;
image2yuvconfig(&frame->img, &sd);
return vp10_set_reference_dec(&frame_worker_data->pbi->common,
return av1_set_reference_dec(&frame_worker_data->pbi->common,
(VPX_REFFRAME)frame->frame_type, &sd);
} else {
return VPX_CODEC_INVALID_PARAM;
@ -800,7 +800,7 @@ static aom_codec_err_t ctrl_copy_reference(aom_codec_alg_priv_t *ctx,
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1;
image2yuvconfig(&frame->img, &sd);
return vp10_copy_reference_dec(frame_worker_data->pbi,
return av1_copy_reference_dec(frame_worker_data->pbi,
(VPX_REFFRAME)frame->frame_type, &sd);
} else {
return VPX_CODEC_INVALID_PARAM;
@ -908,7 +908,7 @@ static aom_codec_err_t ctrl_get_frame_size(aom_codec_alg_priv_t *ctx,
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
const AV1_COMMON *const cm = &frame_worker_data->pbi->common;
frame_size[0] = cm->width;
frame_size[1] = cm->height;
return VPX_CODEC_OK;
@ -935,7 +935,7 @@ static aom_codec_err_t ctrl_get_render_size(aom_codec_alg_priv_t *ctx,
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
const AV1_COMMON *const cm = &frame_worker_data->pbi->common;
render_size[0] = cm->render_width;
render_size[1] = cm->render_height;
return VPX_CODEC_OK;
@ -956,7 +956,7 @@ static aom_codec_err_t ctrl_get_bit_depth(aom_codec_alg_priv_t *ctx,
if (worker) {
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
const AV1_COMMON *const cm = &frame_worker_data->pbi->common;
*bit_depth = cm->bit_depth;
return VPX_CODEC_OK;
} else {
@ -1045,8 +1045,8 @@ static aom_codec_ctrl_fn_map_t decoder_ctrl_maps[] = {
#ifndef VERSION_STRING
#define VERSION_STRING
#endif
CODEC_INTERFACE(aom_codec_vp10_dx) = {
"WebM Project VP10 Decoder" VERSION_STRING,
CODEC_INTERFACE(aom_codec_av1_dx) = {
"WebM Project AV1 Decoder" VERSION_STRING,
VPX_CODEC_INTERNAL_ABI_VERSION,
VPX_CODEC_CAP_DECODER |
VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER, // aom_codec_caps_t

14
av1/av1_iface_common.h
Просмотреть файл

@ -8,8 +8,8 @@
* 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 VP10_VP10_IFACE_COMMON_H_
#define VP10_VP10_IFACE_COMMON_H_
#ifndef AV1_AV1_IFACE_COMMON_H_
#define AV1_AV1_IFACE_COMMON_H_
#include "aom_ports/mem.h"
@ -56,7 +56,7 @@ static void yuvconfig2image(aom_image_t *img, const YV12_BUFFER_CONFIG *yv12,
img->stride[VPX_PLANE_U] = yv12->uv_stride;
img->stride[VPX_PLANE_V] = yv12->uv_stride;
img->stride[VPX_PLANE_ALPHA] = yv12->y_stride;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (yv12->flags & YV12_FLAG_HIGHBITDEPTH) {
// aom_image_t uses byte strides and a pointer to the first byte
// of the image.
@ -71,7 +71,7 @@ static void yuvconfig2image(aom_image_t *img, const YV12_BUFFER_CONFIG *yv12,
img->stride[VPX_PLANE_V] = 2 * yv12->uv_stride;
img->stride[VPX_PLANE_ALPHA] = 2 * yv12->y_stride;
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
img->bps = bps;
img->user_priv = user_priv;
img->img_data = yv12->buffer_alloc;
@ -104,7 +104,7 @@ static aom_codec_err_t image2yuvconfig(const aom_image_t *img,
yv12->color_space = img->cs;
yv12->color_range = img->range;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
// In aom_image_t
// planes point to uint8 address of start of data
@ -128,10 +128,10 @@ static aom_codec_err_t image2yuvconfig(const aom_image_t *img,
yv12->border = (yv12->y_stride - img->w) / 2;
#else
yv12->border = (img->stride[VPX_PLANE_Y] - img->w) / 2;
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
yv12->subsampling_x = img->x_chroma_shift;
yv12->subsampling_y = img->y_chroma_shift;
return VPX_CODEC_OK;
}
#endif // VP10_VP10_IFACE_COMMON_H_
#endif // AV1_AV1_IFACE_COMMON_H_

24
av1/common/alloccommon.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "av1/common/entropymv.h"
#include "av1/common/onyxc_int.h"
void vp10_set_mb_mi(VP10_COMMON *cm, int width, int height) {
void av1_set_mb_mi(AV1_COMMON *cm, int width, int height) {
const int aligned_width = ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2);
const int aligned_height = ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2);
@ -31,7 +31,7 @@ void vp10_set_mb_mi(VP10_COMMON *cm, int width, int height) {
cm->MBs = cm->mb_rows * cm->mb_cols;
}
static int alloc_seg_map(VP10_COMMON *cm, int seg_map_size) {
static int alloc_seg_map(AV1_COMMON *cm, int seg_map_size) {
int i;
for (i = 0; i < NUM_PING_PONG_BUFFERS; ++i) {
@ -51,7 +51,7 @@ static int alloc_seg_map(VP10_COMMON *cm, int seg_map_size) {
return 0;
}
static void free_seg_map(VP10_COMMON *cm) {
static void free_seg_map(AV1_COMMON *cm) {
int i;
for (i = 0; i < NUM_PING_PONG_BUFFERS; ++i) {
@ -66,7 +66,7 @@ static void free_seg_map(VP10_COMMON *cm) {
}
}
void vp10_free_ref_frame_buffers(BufferPool *pool) {
void av1_free_ref_frame_buffers(BufferPool *pool) {
int i;
for (i = 0; i < FRAME_BUFFERS; ++i) {
@ -81,7 +81,7 @@ void vp10_free_ref_frame_buffers(BufferPool *pool) {
}
}
void vp10_free_context_buffers(VP10_COMMON *cm) {
void av1_free_context_buffers(AV1_COMMON *cm) {
cm->free_mi(cm);
free_seg_map(cm);
aom_free(cm->above_context);
@ -90,10 +90,10 @@ void vp10_free_context_buffers(VP10_COMMON *cm) {
cm->above_seg_context = NULL;
}
int vp10_alloc_context_buffers(VP10_COMMON *cm, int width, int height) {
int av1_alloc_context_buffers(AV1_COMMON *cm, int width, int height) {
int new_mi_size;
vp10_set_mb_mi(cm, width, height);
av1_set_mb_mi(cm, width, height);
new_mi_size = cm->mi_stride * calc_mi_size(cm->mi_rows);
if (cm->mi_alloc_size < new_mi_size) {
cm->free_mi(cm);
@ -123,12 +123,12 @@ int vp10_alloc_context_buffers(VP10_COMMON *cm, int width, int height) {
return 0;
fail:
vp10_free_context_buffers(cm);
av1_free_context_buffers(cm);
return 1;
}
void vp10_remove_common(VP10_COMMON *cm) {
vp10_free_context_buffers(cm);
void av1_remove_common(AV1_COMMON *cm) {
av1_free_context_buffers(cm);
aom_free(cm->fc);
cm->fc = NULL;
@ -136,13 +136,13 @@ void vp10_remove_common(VP10_COMMON *cm) {
cm->frame_contexts = NULL;
}
void vp10_init_context_buffers(VP10_COMMON *cm) {
void av1_init_context_buffers(AV1_COMMON *cm) {
cm->setup_mi(cm);
if (cm->last_frame_seg_map && !cm->frame_parallel_decode)
memset(cm->last_frame_seg_map, 0, cm->mi_rows * cm->mi_cols);
}
void vp10_swap_current_and_last_seg_map(VP10_COMMON *cm) {
void av1_swap_current_and_last_seg_map(AV1_COMMON *cm) {
// Swap indices.
const int tmp = cm->seg_map_idx;
cm->seg_map_idx = cm->prev_seg_map_idx;

26
av1/common/alloccommon.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ALLOCCOMMON_H_
#define VP10_COMMON_ALLOCCOMMON_H_
#ifndef AV1_COMMON_ALLOCCOMMON_H_
#define AV1_COMMON_ALLOCCOMMON_H_
#define INVALID_IDX -1 // Invalid buffer index.
@ -18,26 +18,26 @@
extern "C" {
#endif
struct VP10Common;
struct AV1Common;
struct BufferPool;
void vp10_remove_common(struct VP10Common *cm);
void av1_remove_common(struct AV1Common *cm);
int vp10_alloc_context_buffers(struct VP10Common *cm, int width, int height);
void vp10_init_context_buffers(struct VP10Common *cm);
void vp10_free_context_buffers(struct VP10Common *cm);
int av1_alloc_context_buffers(struct AV1Common *cm, int width, int height);
void av1_init_context_buffers(struct AV1Common *cm);
void av1_free_context_buffers(struct AV1Common *cm);
void vp10_free_ref_frame_buffers(struct BufferPool *pool);
void av1_free_ref_frame_buffers(struct BufferPool *pool);
int vp10_alloc_state_buffers(struct VP10Common *cm, int width, int height);
void vp10_free_state_buffers(struct VP10Common *cm);
int av1_alloc_state_buffers(struct AV1Common *cm, int width, int height);
void av1_free_state_buffers(struct AV1Common *cm);
void vp10_set_mb_mi(struct VP10Common *cm, int width, int height);
void av1_set_mb_mi(struct AV1Common *cm, int width, int height);
void vp10_swap_current_and_last_seg_map(struct VP10Common *cm);
void av1_swap_current_and_last_seg_map(struct AV1Common *cm);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_ALLOCCOMMON_H_
#endif // AV1_COMMON_ALLOCCOMMON_H_

4
av1/common/arm/neon/iht4x4_add_neon.c
Просмотреть файл

@ -140,7 +140,7 @@ static INLINE void IADST4x4_1D(int16x4_t *d3s16, int16x4_t *d4s16,
return;
}
void vp10_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest,
void av1_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest,
int dest_stride, int tx_type) {
uint8x8_t d26u8, d27u8;
int16x4_t d0s16, d1s16, d2s16, d3s16, d4s16, d5s16;
@ -157,7 +157,7 @@ void vp10_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest,
switch (tx_type) {
case 0: // idct_idct is not supported. Fall back to C
vp10_iht4x4_16_add_c(input, dest, dest_stride, tx_type);
av1_iht4x4_16_add_c(input, dest, dest_stride, tx_type);
return;
break;
case 1: // iadst_idct

4
av1/common/arm/neon/iht8x8_add_neon.c
Просмотреть файл

@ -472,7 +472,7 @@ static INLINE void IADST8X8_1D(int16x8_t *q8s16, int16x8_t *q9s16,
return;
}
void vp10_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest,
void av1_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest,
int dest_stride, int tx_type) {
int i;
uint8_t *d1, *d2;
@ -495,7 +495,7 @@ void vp10_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest,
switch (tx_type) {
case 0: // idct_idct is not supported. Fall back to C
vp10_iht8x8_64_add_c(input, dest, dest_stride, tx_type);
av1_iht8x8_64_add_c(input, dest, dest_stride, tx_type);
return;
break;
case 1: // iadst_idct

66
av1/common/av1_fwd_txfm.c
Просмотреть файл

@ -11,7 +11,7 @@
#include "av1/common/av1_fwd_txfm.h"
void vp10_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride) {
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
@ -77,7 +77,7 @@ void vp10_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride) {
}
}
void vp10_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride) {
int r, c;
tran_low_t sum = 0;
for (r = 0; r < 4; ++r)
@ -87,7 +87,7 @@ void vp10_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride) {
output[1] = 0;
}
void vp10_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
void av1_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
int stride) {
int i, j;
tran_low_t intermediate[64];
@ -173,7 +173,7 @@ void vp10_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
}
}
void vp10_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride) {
int r, c;
tran_low_t sum = 0;
for (r = 0; r < 8; ++r)
@ -183,7 +183,7 @@ void vp10_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride) {
output[1] = 0;
}
void vp10_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride) {
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
@ -363,7 +363,7 @@ void vp10_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride) {
}
}
void vp10_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride) {
int r, c;
tran_low_t sum = 0;
for (r = 0; r < 16; ++r)
@ -386,7 +386,7 @@ static INLINE tran_high_t half_round_shift(tran_high_t input) {
return rv;
}
void vp10_fdct32(const tran_high_t *input, tran_high_t *output, int round) {
void av1_fdct32(const tran_high_t *input, tran_high_t *output, int round) {
tran_high_t step[32];
// Stage 1
step[0] = input[0] + input[(32 - 1)];
@ -709,7 +709,7 @@ void vp10_fdct32(const tran_high_t *input, tran_high_t *output, int round) {
output[31] = dct_32_round(step[31] * cospi_31_64 + step[16] * -cospi_1_64);
}
void vp10_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
void av1_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
int i, j;
tran_high_t output[32 * 32];
@ -717,7 +717,7 @@ void vp10_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
for (i = 0; i < 32; ++i) {
tran_high_t temp_in[32], temp_out[32];
for (j = 0; j < 32; ++j) temp_in[j] = input[j * stride + i] * 4;
vp10_fdct32(temp_in, temp_out, 0);
av1_fdct32(temp_in, temp_out, 0);
for (j = 0; j < 32; ++j)
output[j * 32 + i] = (temp_out[j] + 1 + (temp_out[j] > 0)) >> 2;
}
@ -726,7 +726,7 @@ void vp10_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
for (i = 0; i < 32; ++i) {
tran_high_t temp_in[32], temp_out[32];
for (j = 0; j < 32; ++j) temp_in[j] = output[j + i * 32];
vp10_fdct32(temp_in, temp_out, 0);
av1_fdct32(temp_in, temp_out, 0);
for (j = 0; j < 32; ++j)
out[j + i * 32] =
(tran_low_t)((temp_out[j] + 1 + (temp_out[j] < 0)) >> 2);
@ -736,7 +736,7 @@ void vp10_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
// Note that although we use dct_32_round in dct32 computation flow,
// this 2d fdct32x32 for rate-distortion optimization loop is operating
// within 16 bits precision.
void vp10_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
void av1_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
int i, j;
tran_high_t output[32 * 32];
@ -744,11 +744,11 @@ void vp10_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
for (i = 0; i < 32; ++i) {
tran_high_t temp_in[32], temp_out[32];
for (j = 0; j < 32; ++j) temp_in[j] = input[j * stride + i] * 4;
vp10_fdct32(temp_in, temp_out, 0);
av1_fdct32(temp_in, temp_out, 0);
for (j = 0; j < 32; ++j)
// TODO(cd): see quality impact of only doing
// output[j * 32 + i] = (temp_out[j] + 1) >> 2;
// PS: also change code in vp10_dsp/x86/vp10_dct_sse2.c
// PS: also change code in av1_dsp/x86/av1_dct_sse2.c
output[j * 32 + i] = (temp_out[j] + 1 + (temp_out[j] > 0)) >> 2;
}
@ -756,12 +756,12 @@ void vp10_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
for (i = 0; i < 32; ++i) {
tran_high_t temp_in[32], temp_out[32];
for (j = 0; j < 32; ++j) temp_in[j] = output[j + i * 32];
vp10_fdct32(temp_in, temp_out, 1);
av1_fdct32(temp_in, temp_out, 1);
for (j = 0; j < 32; ++j) out[j + i * 32] = (tran_low_t)temp_out[j];
}
}
void vp10_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride) {
void av1_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride) {
int r, c;
tran_low_t sum = 0;
for (r = 0; r < 32; ++r)
@ -771,44 +771,44 @@ void vp10_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride) {
output[1] = 0;
}
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output,
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output,
int stride) {
vp10_fdct4x4_c(input, output, stride);
av1_fdct4x4_c(input, output, stride);
}
void vp10_highbd_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
void av1_highbd_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
int stride) {
vp10_fdct8x8_c(input, final_output, stride);
av1_fdct8x8_c(input, final_output, stride);
}
void vp10_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *final_output,
void av1_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *final_output,
int stride) {
vp10_fdct8x8_1_c(input, final_output, stride);
av1_fdct8x8_1_c(input, final_output, stride);
}
void vp10_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output,
void av1_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output,
int stride) {
vp10_fdct16x16_c(input, output, stride);
av1_fdct16x16_c(input, output, stride);
}
void vp10_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output,
void av1_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output,
int stride) {
vp10_fdct16x16_1_c(input, output, stride);
av1_fdct16x16_1_c(input, output, stride);
}
void vp10_highbd_fdct32x32_c(const int16_t *input, tran_low_t *out,
void av1_highbd_fdct32x32_c(const int16_t *input, tran_low_t *out,
int stride) {
vp10_fdct32x32_c(input, out, stride);
av1_fdct32x32_c(input, out, stride);
}
void vp10_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *out,
void av1_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *out,
int stride) {
vp10_fdct32x32_rd_c(input, out, stride);
av1_fdct32x32_rd_c(input, out, stride);
}
void vp10_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *out,
void av1_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *out,
int stride) {
vp10_fdct32x32_1_c(input, out, stride);
av1_fdct32x32_1_c(input, out, stride);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

8
av1/common/av1_fwd_txfm.h
Просмотреть файл

@ -9,11 +9,11 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_VP10_FWD_TXFM_H_
#define VP10_COMMON_VP10_FWD_TXFM_H_
#ifndef AV1_COMMON_AV1_FWD_TXFM_H_
#define AV1_COMMON_AV1_FWD_TXFM_H_
#include "aom_dsp/txfm_common.h"
#include "aom_dsp/fwd_txfm.h"
void vp10_fdct32(const tran_high_t *input, tran_high_t *output, int round);
#endif // VP10_COMMON_VP10_FWD_TXFM_H_
void av1_fdct32(const tran_high_t *input, tran_high_t *output, int round);
#endif // AV1_COMMON_AV1_FWD_TXFM_H_

132
av1/common/av1_inv_txfm.c
Просмотреть файл

@ -13,7 +13,7 @@
#include "av1/common/av1_inv_txfm.h"
void vp10_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
void av1_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
/* 4-point reversible, orthonormal inverse Walsh-Hadamard in 3.5 adds,
0.5 shifts per pixel. */
int i;
@ -65,7 +65,7 @@ void vp10_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
void vp10_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest,
void av1_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest,
int dest_stride) {
int i;
tran_high_t a1, e1;
@ -92,7 +92,7 @@ void vp10_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest,
}
}
void vp10_idct4_c(const tran_low_t *input, tran_low_t *output) {
void av1_idct4_c(const tran_low_t *input, tran_low_t *output) {
tran_low_t step[4];
tran_high_t temp1, temp2;
// stage 1
@ -112,7 +112,7 @@ void vp10_idct4_c(const tran_low_t *input, tran_low_t *output) {
output[3] = WRAPLOW(step[0] - step[3], 8);
}
void vp10_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
void av1_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
tran_low_t out[4 * 4];
tran_low_t *outptr = out;
int i, j;
@ -120,7 +120,7 @@ void vp10_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// Rows
for (i = 0; i < 4; ++i) {
vp10_idct4_c(input, outptr);
av1_idct4_c(input, outptr);
input += 4;
outptr += 4;
}
@ -128,7 +128,7 @@ void vp10_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// Columns
for (i = 0; i < 4; ++i) {
for (j = 0; j < 4; ++j) temp_in[j] = out[j * 4 + i];
vp10_idct4_c(temp_in, temp_out);
av1_idct4_c(temp_in, temp_out);
for (j = 0; j < 4; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 4));
@ -136,7 +136,7 @@ void vp10_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
void vp10_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest,
int dest_stride) {
int i;
tran_high_t a1;
@ -153,7 +153,7 @@ void vp10_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_idct8_c(const tran_low_t *input, tran_low_t *output) {
void av1_idct8_c(const tran_low_t *input, tran_low_t *output) {
tran_low_t step1[8], step2[8];
tran_high_t temp1, temp2;
// stage 1
@ -207,7 +207,7 @@ void vp10_idct8_c(const tran_low_t *input, tran_low_t *output) {
output[7] = WRAPLOW(step1[0] - step1[7], 8);
}
void vp10_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
void av1_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
tran_low_t out[8 * 8];
tran_low_t *outptr = out;
int i, j;
@ -215,7 +215,7 @@ void vp10_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// First transform rows
for (i = 0; i < 8; ++i) {
vp10_idct8_c(input, outptr);
av1_idct8_c(input, outptr);
input += 8;
outptr += 8;
}
@ -223,7 +223,7 @@ void vp10_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// Then transform columns
for (i = 0; i < 8; ++i) {
for (j = 0; j < 8; ++j) temp_in[j] = out[j * 8 + i];
vp10_idct8_c(temp_in, temp_out);
av1_idct8_c(temp_in, temp_out);
for (j = 0; j < 8; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 5));
@ -231,7 +231,7 @@ void vp10_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
void vp10_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
void av1_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
int i, j;
tran_high_t a1;
tran_low_t out = WRAPLOW(dct_const_round_shift(input[0] * cospi_16_64), 8);
@ -243,7 +243,7 @@ void vp10_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
void vp10_iadst4_c(const tran_low_t *input, tran_low_t *output) {
void av1_iadst4_c(const tran_low_t *input, tran_low_t *output) {
tran_high_t s0, s1, s2, s3, s4, s5, s6, s7;
tran_low_t x0 = input[0];
@ -280,7 +280,7 @@ void vp10_iadst4_c(const tran_low_t *input, tran_low_t *output) {
output[3] = WRAPLOW(dct_const_round_shift(s0 + s1 - s3), 8);
}
void vp10_iadst8_c(const tran_low_t *input, tran_low_t *output) {
void av1_iadst8_c(const tran_low_t *input, tran_low_t *output) {
int s0, s1, s2, s3, s4, s5, s6, s7;
tran_high_t x0 = input[7];
@ -357,7 +357,7 @@ void vp10_iadst8_c(const tran_low_t *input, tran_low_t *output) {
output[7] = WRAPLOW(-x1, 8);
}
void vp10_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
void av1_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
tran_low_t out[8 * 8] = { 0 };
tran_low_t *outptr = out;
int i, j;
@ -366,7 +366,7 @@ void vp10_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// First transform rows
// only first 4 row has non-zero coefs
for (i = 0; i < 4; ++i) {
vp10_idct8_c(input, outptr);
av1_idct8_c(input, outptr);
input += 8;
outptr += 8;
}
@ -374,7 +374,7 @@ void vp10_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
// Then transform columns
for (i = 0; i < 8; ++i) {
for (j = 0; j < 8; ++j) temp_in[j] = out[j * 8 + i];
vp10_idct8_c(temp_in, temp_out);
av1_idct8_c(temp_in, temp_out);
for (j = 0; j < 8; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 5));
@ -382,7 +382,7 @@ void vp10_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride) {
}
}
void vp10_idct16_c(const tran_low_t *input, tran_low_t *output) {
void av1_idct16_c(const tran_low_t *input, tran_low_t *output) {
tran_low_t step1[16], step2[16];
tran_high_t temp1, temp2;
@ -547,7 +547,7 @@ void vp10_idct16_c(const tran_low_t *input, tran_low_t *output) {
output[15] = WRAPLOW(step2[0] - step2[15], 8);
}
void vp10_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
tran_low_t out[16 * 16];
tran_low_t *outptr = out;
@ -556,7 +556,7 @@ void vp10_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest,
// First transform rows
for (i = 0; i < 16; ++i) {
vp10_idct16_c(input, outptr);
av1_idct16_c(input, outptr);
input += 16;
outptr += 16;
}
@ -564,7 +564,7 @@ void vp10_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest,
// Then transform columns
for (i = 0; i < 16; ++i) {
for (j = 0; j < 16; ++j) temp_in[j] = out[j * 16 + i];
vp10_idct16_c(temp_in, temp_out);
av1_idct16_c(temp_in, temp_out);
for (j = 0; j < 16; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 6));
@ -572,7 +572,7 @@ void vp10_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_iadst16_c(const tran_low_t *input, tran_low_t *output) {
void av1_iadst16_c(const tran_low_t *input, tran_low_t *output) {
tran_high_t s0, s1, s2, s3, s4, s5, s6, s7, s8;
tran_high_t s9, s10, s11, s12, s13, s14, s15;
@ -743,7 +743,7 @@ void vp10_iadst16_c(const tran_low_t *input, tran_low_t *output) {
output[15] = WRAPLOW(-x1, 8);
}
void vp10_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
tran_low_t out[16 * 16] = { 0 };
tran_low_t *outptr = out;
@ -753,7 +753,7 @@ void vp10_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest,
// First transform rows. Since all non-zero dct coefficients are in
// upper-left 4x4 area, we only need to calculate first 4 rows here.
for (i = 0; i < 4; ++i) {
vp10_idct16_c(input, outptr);
av1_idct16_c(input, outptr);
input += 16;
outptr += 16;
}
@ -761,7 +761,7 @@ void vp10_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest,
// Then transform columns
for (i = 0; i < 16; ++i) {
for (j = 0; j < 16; ++j) temp_in[j] = out[j * 16 + i];
vp10_idct16_c(temp_in, temp_out);
av1_idct16_c(temp_in, temp_out);
for (j = 0; j < 16; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 6));
@ -769,7 +769,7 @@ void vp10_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
int i, j;
tran_high_t a1;
@ -782,7 +782,7 @@ void vp10_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_idct32_c(const tran_low_t *input, tran_low_t *output) {
void av1_idct32_c(const tran_low_t *input, tran_low_t *output) {
tran_low_t step1[32], step2[32];
tran_high_t temp1, temp2;
@ -1149,7 +1149,7 @@ void vp10_idct32_c(const tran_low_t *input, tran_low_t *output) {
output[31] = WRAPLOW(step1[0] - step1[31], 8);
}
void vp10_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
tran_low_t out[32 * 32];
tran_low_t *outptr = out;
@ -1168,7 +1168,7 @@ void vp10_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest,
zero_coeff[j] = zero_coeff[2 * j] | zero_coeff[2 * j + 1];
if (zero_coeff[0] | zero_coeff[1])
vp10_idct32_c(input, outptr);
av1_idct32_c(input, outptr);
else
memset(outptr, 0, sizeof(tran_low_t) * 32);
input += 32;
@ -1178,7 +1178,7 @@ void vp10_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest,
// Columns
for (i = 0; i < 32; ++i) {
for (j = 0; j < 32; ++j) temp_in[j] = out[j * 32 + i];
vp10_idct32_c(temp_in, temp_out);
av1_idct32_c(temp_in, temp_out);
for (j = 0; j < 32; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 6));
@ -1186,7 +1186,7 @@ void vp10_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
tran_low_t out[32 * 32] = { 0 };
tran_low_t *outptr = out;
@ -1196,7 +1196,7 @@ void vp10_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest,
// Rows
// only upper-left 8x8 has non-zero coeff
for (i = 0; i < 8; ++i) {
vp10_idct32_c(input, outptr);
av1_idct32_c(input, outptr);
input += 32;
outptr += 32;
}
@ -1204,7 +1204,7 @@ void vp10_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest,
// Columns
for (i = 0; i < 32; ++i) {
for (j = 0; j < 32; ++j) temp_in[j] = out[j * 32 + i];
vp10_idct32_c(temp_in, temp_out);
av1_idct32_c(temp_in, temp_out);
for (j = 0; j < 32; ++j) {
dest[j * stride + i] = clip_pixel_add(dest[j * stride + i],
ROUND_POWER_OF_TWO(temp_out[j], 6));
@ -1212,7 +1212,7 @@ void vp10_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest,
void av1_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest,
int stride) {
int i, j;
tran_high_t a1;
@ -1227,8 +1227,8 @@ void vp10_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
/* 4-point reversible, orthonormal inverse Walsh-Hadamard in 3.5 adds,
0.5 shifts per pixel. */
@ -1282,7 +1282,7 @@ void vp10_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest8,
void av1_highbd_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest8,
int dest_stride, int bd) {
int i;
tran_high_t a1, e1;
@ -1315,7 +1315,7 @@ void vp10_highbd_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest8,
}
}
void vp10_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd) {
void av1_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd) {
tran_low_t step[4];
tran_high_t temp1, temp2;
(void)bd;
@ -1336,7 +1336,7 @@ void vp10_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd) {
output[3] = WRAPLOW(step[0] - step[3], bd);
}
void vp10_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[4 * 4];
tran_low_t *outptr = out;
@ -1346,7 +1346,7 @@ void vp10_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
// Rows
for (i = 0; i < 4; ++i) {
vp10_highbd_idct4_c(input, outptr, bd);
av1_highbd_idct4_c(input, outptr, bd);
input += 4;
outptr += 4;
}
@ -1354,7 +1354,7 @@ void vp10_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
// Columns
for (i = 0; i < 4; ++i) {
for (j = 0; j < 4; ++j) temp_in[j] = out[j * 4 + i];
vp10_highbd_idct4_c(temp_in, temp_out, bd);
av1_highbd_idct4_c(temp_in, temp_out, bd);
for (j = 0; j < 4; ++j) {
dest[j * stride + i] = highbd_clip_pixel_add(
dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 4), bd);
@ -1362,7 +1362,7 @@ void vp10_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest8,
int dest_stride, int bd) {
int i;
tran_high_t a1;
@ -1382,7 +1382,7 @@ void vp10_highbd_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd) {
void av1_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd) {
tran_low_t step1[8], step2[8];
tran_high_t temp1, temp2;
// stage 1
@ -1400,7 +1400,7 @@ void vp10_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd) {
step1[6] = WRAPLOW(highbd_dct_const_round_shift(temp2, bd), bd);
// stage 2 & stage 3 - even half
vp10_highbd_idct4_c(step1, step1, bd);
av1_highbd_idct4_c(step1, step1, bd);
// stage 2 - odd half
step2[4] = WRAPLOW(step1[4] + step1[5], bd);
@ -1427,7 +1427,7 @@ void vp10_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd) {
output[7] = WRAPLOW(step1[0] - step1[7], bd);
}
void vp10_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[8 * 8];
tran_low_t *outptr = out;
@ -1437,7 +1437,7 @@ void vp10_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
// First transform rows.
for (i = 0; i < 8; ++i) {
vp10_highbd_idct8_c(input, outptr, bd);
av1_highbd_idct8_c(input, outptr, bd);
input += 8;
outptr += 8;
}
@ -1445,7 +1445,7 @@ void vp10_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
// Then transform columns.
for (i = 0; i < 8; ++i) {
for (j = 0; j < 8; ++j) temp_in[j] = out[j * 8 + i];
vp10_highbd_idct8_c(temp_in, temp_out, bd);
av1_highbd_idct8_c(temp_in, temp_out, bd);
for (j = 0; j < 8; ++j) {
dest[j * stride + i] = highbd_clip_pixel_add(
dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 5), bd);
@ -1453,7 +1453,7 @@ void vp10_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
tran_high_t a1;
@ -1468,7 +1468,7 @@ void vp10_highbd_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_iadst4_c(const tran_low_t *input, tran_low_t *output, int bd) {
void av1_highbd_iadst4_c(const tran_low_t *input, tran_low_t *output, int bd) {
tran_high_t s0, s1, s2, s3, s4, s5, s6, s7;
tran_low_t x0 = input[0];
@ -1506,7 +1506,7 @@ void vp10_highbd_iadst4_c(const tran_low_t *input, tran_low_t *output, int bd) {
output[3] = WRAPLOW(highbd_dct_const_round_shift(s0 + s1 - s3, bd), bd);
}
void vp10_highbd_iadst8_c(const tran_low_t *input, tran_low_t *output, int bd) {
void av1_highbd_iadst8_c(const tran_low_t *input, tran_low_t *output, int bd) {
tran_high_t s0, s1, s2, s3, s4, s5, s6, s7;
tran_low_t x0 = input[7];
@ -1583,7 +1583,7 @@ void vp10_highbd_iadst8_c(const tran_low_t *input, tran_low_t *output, int bd) {
output[7] = WRAPLOW(-x1, bd);
}
void vp10_highbd_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[8 * 8] = { 0 };
tran_low_t *outptr = out;
@ -1594,14 +1594,14 @@ void vp10_highbd_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
// First transform rows.
// Only first 4 row has non-zero coefs.
for (i = 0; i < 4; ++i) {
vp10_highbd_idct8_c(input, outptr, bd);
av1_highbd_idct8_c(input, outptr, bd);
input += 8;
outptr += 8;
}
// Then transform columns.
for (i = 0; i < 8; ++i) {
for (j = 0; j < 8; ++j) temp_in[j] = out[j * 8 + i];
vp10_highbd_idct8_c(temp_in, temp_out, bd);
av1_highbd_idct8_c(temp_in, temp_out, bd);
for (j = 0; j < 8; ++j) {
dest[j * stride + i] = highbd_clip_pixel_add(
dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 5), bd);
@ -1609,7 +1609,7 @@ void vp10_highbd_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd) {
void av1_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd) {
tran_low_t step1[16], step2[16];
tran_high_t temp1, temp2;
(void)bd;
@ -1775,7 +1775,7 @@ void vp10_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd) {
output[15] = WRAPLOW(step2[0] - step2[15], bd);
}
void vp10_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[16 * 16];
tran_low_t *outptr = out;
@ -1785,7 +1785,7 @@ void vp10_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
// First transform rows.
for (i = 0; i < 16; ++i) {
vp10_highbd_idct16_c(input, outptr, bd);
av1_highbd_idct16_c(input, outptr, bd);
input += 16;
outptr += 16;
}
@ -1793,7 +1793,7 @@ void vp10_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
// Then transform columns.
for (i = 0; i < 16; ++i) {
for (j = 0; j < 16; ++j) temp_in[j] = out[j * 16 + i];
vp10_highbd_idct16_c(temp_in, temp_out, bd);
av1_highbd_idct16_c(temp_in, temp_out, bd);
for (j = 0; j < 16; ++j) {
dest[j * stride + i] = highbd_clip_pixel_add(
dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 6), bd);
@ -1801,7 +1801,7 @@ void vp10_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_iadst16_c(const tran_low_t *input, tran_low_t *output,
void av1_highbd_iadst16_c(const tran_low_t *input, tran_low_t *output,
int bd) {
tran_high_t s0, s1, s2, s3, s4, s5, s6, s7, s8;
tran_high_t s9, s10, s11, s12, s13, s14, s15;
@ -1972,7 +1972,7 @@ void vp10_highbd_iadst16_c(const tran_low_t *input, tran_low_t *output,
output[15] = WRAPLOW(-x1, bd);
}
void vp10_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[16 * 16] = { 0 };
tran_low_t *outptr = out;
@ -1983,7 +1983,7 @@ void vp10_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
// First transform rows. Since all non-zero dct coefficients are in
// upper-left 4x4 area, we only need to calculate first 4 rows here.
for (i = 0; i < 4; ++i) {
vp10_highbd_idct16_c(input, outptr, bd);
av1_highbd_idct16_c(input, outptr, bd);
input += 16;
outptr += 16;
}
@ -1991,7 +1991,7 @@ void vp10_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
// Then transform columns.
for (i = 0; i < 16; ++i) {
for (j = 0; j < 16; ++j) temp_in[j] = out[j * 16 + i];
vp10_highbd_idct16_c(temp_in, temp_out, bd);
av1_highbd_idct16_c(temp_in, temp_out, bd);
for (j = 0; j < 16; ++j) {
dest[j * stride + i] = highbd_clip_pixel_add(
dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 6), bd);
@ -1999,7 +1999,7 @@ void vp10_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
tran_high_t a1;
@ -2384,7 +2384,7 @@ static void highbd_idct32_c(const tran_low_t *input, tran_low_t *output,
output[31] = WRAPLOW(step1[0] - step1[31], bd);
}
void vp10_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[32 * 32];
tran_low_t *outptr = out;
@ -2422,7 +2422,7 @@ void vp10_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[32 * 32] = { 0 };
tran_low_t *outptr = out;
@ -2448,7 +2448,7 @@ void vp10_highbd_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp10_highbd_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
int a1;
@ -2464,4 +2464,4 @@ void vp10_highbd_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
dest += stride;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

32
av1/common/av1_inv_txfm.h
Просмотреть файл

@ -41,7 +41,7 @@ static INLINE tran_low_t dct_const_round_shift(tran_high_t input) {
return check_range(rv);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE tran_low_t highbd_check_range(tran_high_t input, int bd) {
#if CONFIG_COEFFICIENT_RANGE_CHECKING
// For valid highbitdepth streams, intermediate stage coefficients will
@ -64,7 +64,7 @@ static INLINE tran_low_t highbd_dct_const_round_shift(tran_high_t input,
tran_high_t rv = ROUND_POWER_OF_TWO(input, DCT_CONST_BITS);
return highbd_check_range(rv, bd);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#if CONFIG_EMULATE_HARDWARE
// When CONFIG_EMULATE_HARDWARE is 1 the transform performs a
@ -88,22 +88,22 @@ static INLINE tran_low_t highbd_dct_const_round_shift(tran_high_t input,
#define WRAPLOW(x, bd) ((int32_t)(x))
#endif // CONFIG_EMULATE_HARDWARE
void vp10_idct4_c(const tran_low_t *input, tran_low_t *output);
void vp10_idct8_c(const tran_low_t *input, tran_low_t *output);
void vp10_idct16_c(const tran_low_t *input, tran_low_t *output);
void vp10_idct32_c(const tran_low_t *input, tran_low_t *output);
void vp10_iadst4_c(const tran_low_t *input, tran_low_t *output);
void vp10_iadst8_c(const tran_low_t *input, tran_low_t *output);
void vp10_iadst16_c(const tran_low_t *input, tran_low_t *output);
void av1_idct4_c(const tran_low_t *input, tran_low_t *output);
void av1_idct8_c(const tran_low_t *input, tran_low_t *output);
void av1_idct16_c(const tran_low_t *input, tran_low_t *output);
void av1_idct32_c(const tran_low_t *input, tran_low_t *output);
void av1_iadst4_c(const tran_low_t *input, tran_low_t *output);
void av1_iadst8_c(const tran_low_t *input, tran_low_t *output);
void av1_iadst16_c(const tran_low_t *input, tran_low_t *output);
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd);
void vp10_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd);
void vp10_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd);
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_idct4_c(const tran_low_t *input, tran_low_t *output, int bd);
void av1_highbd_idct8_c(const tran_low_t *input, tran_low_t *output, int bd);
void av1_highbd_idct16_c(const tran_low_t *input, tran_low_t *output, int bd);
void vp10_highbd_iadst4_c(const tran_low_t *input, tran_low_t *output, int bd);
void vp10_highbd_iadst8_c(const tran_low_t *input, tran_low_t *output, int bd);
void vp10_highbd_iadst16_c(const tran_low_t *input, tran_low_t *output, int bd);
void av1_highbd_iadst4_c(const tran_low_t *input, tran_low_t *output, int bd);
void av1_highbd_iadst8_c(const tran_low_t *input, tran_low_t *output, int bd);
void av1_highbd_iadst16_c(const tran_low_t *input, tran_low_t *output, int bd);
static INLINE uint16_t highbd_clip_pixel_add(uint16_t dest, tran_high_t trans,
int bd) {

708
av1/common/av1_rtcd_defs.pl
Просмотреть файл

@ -1,7 +1,7 @@
sub vp10_common_forward_decls() {
sub av1_common_forward_decls() {
print <<EOF
/*
* VP10
* AV1
*/
#include "aom/aom_integer.h"
@ -19,7 +19,7 @@ union int_mv;
struct yv12_buffer_config;
EOF
}
forward_decls qw/vp10_common_forward_decls/;
forward_decls qw/av1_common_forward_decls/;
# x86inc.asm had specific constraints. break it out so it's easy to disable.
# zero all the variables to avoid tricky else conditions.
@ -57,314 +57,314 @@ if ($opts{arch} eq "x86_64") {
#
# dct
#
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# Note as optimized versions of these functions are added we need to add a check to ensure
# that when CONFIG_EMULATE_HARDWARE is on, it defaults to the C versions only.
if (aom_config("CONFIG_EMULATE_HARDWARE") eq "yes") {
add_proto qw/void vp10_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht4x4_16_add/;
add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht4x4_16_add/;
add_proto qw/void vp10_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht8x8_64_add/;
add_proto qw/void av1_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht8x8_64_add/;
add_proto qw/void vp10_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/vp10_iht16x16_256_add/;
add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/av1_iht16x16_256_add/;
add_proto qw/void vp10_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4/;
add_proto qw/void av1_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4/;
add_proto qw/void vp10_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4_1/;
add_proto qw/void av1_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4_1/;
add_proto qw/void vp10_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8/;
add_proto qw/void av1_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8/;
add_proto qw/void vp10_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8_1/;
add_proto qw/void av1_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8_1/;
add_proto qw/void vp10_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16/;
add_proto qw/void av1_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16/;
add_proto qw/void vp10_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16_1/;
add_proto qw/void av1_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16_1/;
add_proto qw/void vp10_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32/;
add_proto qw/void av1_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32/;
add_proto qw/void vp10_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_rd/;
add_proto qw/void av1_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_rd/;
add_proto qw/void vp10_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_1/;
add_proto qw/void av1_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_1/;
add_proto qw/void vp10_highbd_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct4x4/;
add_proto qw/void av1_highbd_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct4x4/;
add_proto qw/void vp10_highbd_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct8x8/;
add_proto qw/void av1_highbd_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct8x8/;
add_proto qw/void vp10_highbd_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct8x8_1/;
add_proto qw/void av1_highbd_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct8x8_1/;
add_proto qw/void vp10_highbd_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct16x16/;
add_proto qw/void av1_highbd_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct16x16/;
add_proto qw/void vp10_highbd_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct16x16_1/;
add_proto qw/void av1_highbd_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct16x16_1/;
add_proto qw/void vp10_highbd_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32/;
add_proto qw/void av1_highbd_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32/;
add_proto qw/void vp10_highbd_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32_rd/;
add_proto qw/void av1_highbd_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32_rd/;
add_proto qw/void vp10_highbd_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32_1/;
add_proto qw/void av1_highbd_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32_1/;
} else {
add_proto qw/void vp10_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht4x4_16_add sse2/;
add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht4x4_16_add sse2/;
add_proto qw/void vp10_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht8x8_64_add sse2/;
add_proto qw/void av1_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht8x8_64_add sse2/;
add_proto qw/void vp10_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/vp10_iht16x16_256_add/;
add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/av1_iht16x16_256_add/;
add_proto qw/void vp10_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4 sse2/;
add_proto qw/void av1_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4 sse2/;
add_proto qw/void vp10_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4_1 sse2/;
add_proto qw/void av1_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4_1 sse2/;
add_proto qw/void vp10_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8 sse2/;
add_proto qw/void av1_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8 sse2/;
add_proto qw/void vp10_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8_1 sse2/;
add_proto qw/void av1_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8_1 sse2/;
add_proto qw/void vp10_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16 sse2/;
add_proto qw/void av1_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16 sse2/;
add_proto qw/void vp10_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16_1 sse2/;
add_proto qw/void av1_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16_1 sse2/;
add_proto qw/void vp10_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32 sse2/;
add_proto qw/void av1_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32 sse2/;
add_proto qw/void vp10_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_rd sse2/;
add_proto qw/void av1_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_rd sse2/;
add_proto qw/void vp10_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_1 sse2/;
add_proto qw/void av1_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_1 sse2/;
add_proto qw/void vp10_highbd_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct4x4 sse2/;
add_proto qw/void av1_highbd_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct4x4 sse2/;
add_proto qw/void vp10_highbd_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct8x8 sse2/;
add_proto qw/void av1_highbd_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct8x8 sse2/;
add_proto qw/void vp10_highbd_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct8x8_1/;
add_proto qw/void av1_highbd_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct8x8_1/;
add_proto qw/void vp10_highbd_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct16x16 sse2/;
add_proto qw/void av1_highbd_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct16x16 sse2/;
add_proto qw/void vp10_highbd_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct16x16_1/;
add_proto qw/void av1_highbd_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct16x16_1/;
add_proto qw/void vp10_highbd_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32 sse2/;
add_proto qw/void av1_highbd_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32 sse2/;
add_proto qw/void vp10_highbd_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32_rd sse2/;
add_proto qw/void av1_highbd_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32_rd sse2/;
add_proto qw/void vp10_highbd_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fdct32x32_1/;
add_proto qw/void av1_highbd_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fdct32x32_1/;
}
} else {
# Force C versions if CONFIG_EMULATE_HARDWARE is 1
if (aom_config("CONFIG_EMULATE_HARDWARE") eq "yes") {
add_proto qw/void vp10_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht4x4_16_add/;
add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht4x4_16_add/;
add_proto qw/void vp10_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht8x8_64_add/;
add_proto qw/void av1_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht8x8_64_add/;
add_proto qw/void vp10_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/vp10_iht16x16_256_add/;
add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/av1_iht16x16_256_add/;
add_proto qw/void vp10_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4/;
add_proto qw/void av1_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4/;
add_proto qw/void vp10_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4_1/;
add_proto qw/void av1_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4_1/;
add_proto qw/void vp10_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8/;
add_proto qw/void av1_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8/;
add_proto qw/void vp10_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8_1/;
add_proto qw/void av1_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8_1/;
add_proto qw/void vp10_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16/;
add_proto qw/void av1_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16/;
add_proto qw/void vp10_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16_1/;
add_proto qw/void av1_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16_1/;
add_proto qw/void vp10_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32/;
add_proto qw/void av1_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32/;
add_proto qw/void vp10_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_rd/;
add_proto qw/void av1_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_rd/;
add_proto qw/void vp10_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_1/;
add_proto qw/void av1_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_1/;
} else {
add_proto qw/void vp10_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht4x4_16_add sse2 neon dspr2 msa/;
add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht4x4_16_add sse2 neon dspr2 msa/;
add_proto qw/void vp10_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/vp10_iht8x8_64_add sse2 neon dspr2 msa/;
add_proto qw/void av1_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
specialize qw/av1_iht8x8_64_add sse2 neon dspr2 msa/;
add_proto qw/void vp10_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/vp10_iht16x16_256_add sse2 dspr2 msa/;
add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
specialize qw/av1_iht16x16_256_add sse2 dspr2 msa/;
add_proto qw/void vp10_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4 sse2/;
add_proto qw/void av1_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4 sse2/;
add_proto qw/void vp10_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct4x4_1 sse2/;
add_proto qw/void av1_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct4x4_1 sse2/;
add_proto qw/void vp10_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8 sse2/;
add_proto qw/void av1_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8 sse2/;
add_proto qw/void vp10_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct8x8_1 sse2/;
add_proto qw/void av1_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct8x8_1 sse2/;
add_proto qw/void vp10_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16 sse2/;
add_proto qw/void av1_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16 sse2/;
add_proto qw/void vp10_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct16x16_1 sse2/;
add_proto qw/void av1_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct16x16_1 sse2/;
add_proto qw/void vp10_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32 sse2/;
add_proto qw/void av1_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32 sse2/;
add_proto qw/void vp10_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_rd sse2/;
add_proto qw/void av1_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_rd sse2/;
add_proto qw/void vp10_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fdct32x32_1 sse2/;
add_proto qw/void av1_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fdct32x32_1 sse2/;
}
}
# High bitdepth functions
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
#
# Sub Pixel Filters
#
add_proto qw/void vp10_highbd_convolve_copy/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve_copy/;
add_proto qw/void av1_highbd_convolve_copy/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve_copy/;
add_proto qw/void vp10_highbd_convolve_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve_avg/;
add_proto qw/void av1_highbd_convolve_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve_avg/;
add_proto qw/void vp10_highbd_convolve8/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8/, "$sse2_x86_64";
add_proto qw/void vp10_highbd_convolve8_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8_horiz/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8_horiz/, "$sse2_x86_64";
add_proto qw/void vp10_highbd_convolve8_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8_vert/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8_vert/, "$sse2_x86_64";
add_proto qw/void vp10_highbd_convolve8_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8_avg/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8_avg/, "$sse2_x86_64";
add_proto qw/void vp10_highbd_convolve8_avg_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8_avg_horiz/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8_avg_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8_avg_horiz/, "$sse2_x86_64";
add_proto qw/void vp10_highbd_convolve8_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/vp10_highbd_convolve8_avg_vert/, "$sse2_x86_64";
add_proto qw/void av1_highbd_convolve8_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
specialize qw/av1_highbd_convolve8_avg_vert/, "$sse2_x86_64";
#
# dct
#
# Note as optimized versions of these functions are added we need to add a check to ensure
# that when CONFIG_EMULATE_HARDWARE is on, it defaults to the C versions only.
add_proto qw/void vp10_highbd_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type, int bd";
specialize qw/vp10_highbd_iht4x4_16_add/;
add_proto qw/void av1_highbd_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type, int bd";
specialize qw/av1_highbd_iht4x4_16_add/;
add_proto qw/void vp10_highbd_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type, int bd";
specialize qw/vp10_highbd_iht8x8_64_add/;
add_proto qw/void av1_highbd_iht8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type, int bd";
specialize qw/av1_highbd_iht8x8_64_add/;
add_proto qw/void vp10_highbd_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type, int bd";
specialize qw/vp10_highbd_iht16x16_256_add/;
add_proto qw/void av1_highbd_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type, int bd";
specialize qw/av1_highbd_iht16x16_256_add/;
}
#
# Encoder functions below this point.
#
if (aom_config("CONFIG_VP10_ENCODER") eq "yes") {
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
# ENCODEMB INVOKE
if (aom_config("CONFIG_AOM_QM") eq "yes") {
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# the transform coefficients are held in 32-bit
# values, so the assembler code for vp10_block_error can no longer be used.
add_proto qw/int64_t vp10_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/vp10_block_error/;
# values, so the assembler code for av1_block_error can no longer be used.
add_proto qw/int64_t av1_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/av1_block_error/;
add_proto qw/void vp10_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void av1_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void vp10_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void av1_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void vp10_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
specialize qw/vp10_fdct8x8_quant/;
add_proto qw/void av1_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
specialize qw/av1_fdct8x8_quant/;
} else {
add_proto qw/int64_t vp10_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/vp10_block_error avx2 msa/, "$sse2_x86inc";
add_proto qw/int64_t av1_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/av1_block_error avx2 msa/, "$sse2_x86inc";
add_proto qw/int64_t vp10_block_error_fp/, "const int16_t *coeff, const int16_t *dqcoeff, int block_size";
specialize qw/vp10_block_error_fp neon/, "$sse2_x86inc";
add_proto qw/int64_t av1_block_error_fp/, "const int16_t *coeff, const int16_t *dqcoeff, int block_size";
specialize qw/av1_block_error_fp neon/, "$sse2_x86inc";
add_proto qw/void vp10_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void av1_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void vp10_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void av1_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void vp10_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
add_proto qw/void av1_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t *iqm_ptr";
}
} else {
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# the transform coefficients are held in 32-bit
# values, so the assembler code for vp10_block_error can no longer be used.
add_proto qw/int64_t vp10_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/vp10_block_error/;
# values, so the assembler code for av1_block_error can no longer be used.
add_proto qw/int64_t av1_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/av1_block_error/;
add_proto qw/void vp10_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_quantize_fp/;
add_proto qw/void av1_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_quantize_fp/;
add_proto qw/void vp10_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_quantize_fp_32x32/;
add_proto qw/void av1_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_quantize_fp_32x32/;
add_proto qw/void vp10_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_fdct8x8_quant/;
add_proto qw/void av1_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_fdct8x8_quant/;
} else {
add_proto qw/int64_t vp10_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/vp10_block_error avx2 msa/, "$sse2_x86inc";
add_proto qw/int64_t av1_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz";
specialize qw/av1_block_error avx2 msa/, "$sse2_x86inc";
add_proto qw/int64_t vp10_block_error_fp/, "const int16_t *coeff, const int16_t *dqcoeff, int block_size";
specialize qw/vp10_block_error_fp neon/, "$sse2_x86inc";
add_proto qw/int64_t av1_block_error_fp/, "const int16_t *coeff, const int16_t *dqcoeff, int block_size";
specialize qw/av1_block_error_fp neon/, "$sse2_x86inc";
add_proto qw/void vp10_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_quantize_fp neon sse2/, "$ssse3_x86_64_x86inc";
add_proto qw/void av1_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_quantize_fp neon sse2/, "$ssse3_x86_64_x86inc";
add_proto qw/void vp10_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_quantize_fp_32x32/, "$ssse3_x86_64_x86inc";
add_proto qw/void av1_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_quantize_fp_32x32/, "$ssse3_x86_64_x86inc";
add_proto qw/void vp10_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_fdct8x8_quant sse2 ssse3 neon/;
add_proto qw/void av1_fdct8x8_quant/, "const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_fdct8x8_quant sse2 ssse3 neon/;
}
}
@ -372,269 +372,269 @@ if (aom_config("CONFIG_AOM_QM") eq "yes") {
# fdct functions
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
add_proto qw/void vp10_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht4x4 sse2/;
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
add_proto qw/void av1_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht4x4 sse2/;
add_proto qw/void vp10_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht8x8 sse2/;
add_proto qw/void av1_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht8x8 sse2/;
add_proto qw/void vp10_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht16x16 sse2/;
add_proto qw/void av1_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht16x16 sse2/;
add_proto qw/void vp10_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fwht4x4/, "$mmx_x86inc";
add_proto qw/void av1_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fwht4x4/, "$mmx_x86inc";
} else {
add_proto qw/void vp10_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht4x4 sse2 msa/;
add_proto qw/void av1_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht4x4 sse2 msa/;
add_proto qw/void vp10_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht8x8 sse2 msa/;
add_proto qw/void av1_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht8x8 sse2 msa/;
add_proto qw/void vp10_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_fht16x16 sse2 msa/;
add_proto qw/void av1_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_fht16x16 sse2 msa/;
add_proto qw/void vp10_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_fwht4x4 msa/, "$mmx_x86inc";
add_proto qw/void av1_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_fwht4x4 msa/, "$mmx_x86inc";
}
# Inverse transform
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# Note as optimized versions of these functions are added we need to add a check to ensure
# that when CONFIG_EMULATE_HARDWARE is on, it defaults to the C versions only.
add_proto qw/void vp10_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_1_add/;
add_proto qw/void av1_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_1_add/;
add_proto qw/void vp10_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_16_add/;
add_proto qw/void av1_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_16_add/;
add_proto qw/void vp10_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_1_add/;
add_proto qw/void av1_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_1_add/;
add_proto qw/void vp10_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_64_add/;
add_proto qw/void av1_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_64_add/;
add_proto qw/void vp10_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_12_add/;
add_proto qw/void av1_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_12_add/;
add_proto qw/void vp10_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_1_add/;
add_proto qw/void av1_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_1_add/;
add_proto qw/void vp10_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_256_add/;
add_proto qw/void av1_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_256_add/;
add_proto qw/void vp10_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_10_add/;
add_proto qw/void av1_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_10_add/;
add_proto qw/void vp10_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1024_add/;
add_proto qw/void av1_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1024_add/;
add_proto qw/void vp10_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_34_add/;
add_proto qw/void av1_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_34_add/;
add_proto qw/void vp10_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1_add/;
add_proto qw/void av1_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1_add/;
add_proto qw/void vp10_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_1_add/;
add_proto qw/void av1_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_1_add/;
add_proto qw/void vp10_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_16_add/;
add_proto qw/void av1_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_16_add/;
add_proto qw/void vp10_highbd_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct4x4_1_add/;
add_proto qw/void av1_highbd_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct4x4_1_add/;
add_proto qw/void vp10_highbd_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct8x8_1_add/;
add_proto qw/void av1_highbd_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct8x8_1_add/;
add_proto qw/void vp10_highbd_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct16x16_1_add/;
add_proto qw/void av1_highbd_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct16x16_1_add/;
add_proto qw/void vp10_highbd_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct32x32_1024_add/;
add_proto qw/void av1_highbd_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct32x32_1024_add/;
add_proto qw/void vp10_highbd_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct32x32_34_add/;
add_proto qw/void av1_highbd_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct32x32_34_add/;
add_proto qw/void vp10_highbd_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct32x32_1_add/;
add_proto qw/void av1_highbd_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct32x32_1_add/;
add_proto qw/void vp10_highbd_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_iwht4x4_1_add/;
add_proto qw/void av1_highbd_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_iwht4x4_1_add/;
add_proto qw/void vp10_highbd_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_iwht4x4_16_add/;
add_proto qw/void av1_highbd_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_iwht4x4_16_add/;
# Force C versions if CONFIG_EMULATE_HARDWARE is 1
if (aom_config("CONFIG_EMULATE_HARDWARE") eq "yes") {
add_proto qw/void vp10_highbd_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct4x4_16_add/;
add_proto qw/void av1_highbd_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct4x4_16_add/;
add_proto qw/void vp10_highbd_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct8x8_64_add/;
add_proto qw/void av1_highbd_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct8x8_64_add/;
add_proto qw/void vp10_highbd_idct8x8_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct8x8_10_add/;
add_proto qw/void av1_highbd_idct8x8_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct8x8_10_add/;
add_proto qw/void vp10_highbd_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct16x16_256_add/;
add_proto qw/void av1_highbd_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct16x16_256_add/;
add_proto qw/void vp10_highbd_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct16x16_10_add/;
add_proto qw/void av1_highbd_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct16x16_10_add/;
} else {
add_proto qw/void vp10_highbd_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct4x4_16_add sse2/;
add_proto qw/void av1_highbd_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct4x4_16_add sse2/;
add_proto qw/void vp10_highbd_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct8x8_64_add sse2/;
add_proto qw/void av1_highbd_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct8x8_64_add sse2/;
add_proto qw/void vp10_highbd_idct8x8_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct8x8_10_add sse2/;
add_proto qw/void av1_highbd_idct8x8_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct8x8_10_add sse2/;
add_proto qw/void vp10_highbd_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct16x16_256_add sse2/;
add_proto qw/void av1_highbd_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct16x16_256_add sse2/;
add_proto qw/void vp10_highbd_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/vp10_highbd_idct16x16_10_add sse2/;
add_proto qw/void av1_highbd_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int bd";
specialize qw/av1_highbd_idct16x16_10_add sse2/;
} # CONFIG_EMULATE_HARDWARE
} else {
# Force C versions if CONFIG_EMULATE_HARDWARE is 1
if (aom_config("CONFIG_EMULATE_HARDWARE") eq "yes") {
add_proto qw/void vp10_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_1_add/;
add_proto qw/void av1_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_1_add/;
add_proto qw/void vp10_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_16_add/;
add_proto qw/void av1_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_16_add/;
add_proto qw/void vp10_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_1_add/;
add_proto qw/void av1_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_1_add/;
add_proto qw/void vp10_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_64_add/;
add_proto qw/void av1_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_64_add/;
add_proto qw/void vp10_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_12_add/;
add_proto qw/void av1_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_12_add/;
add_proto qw/void vp10_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_1_add/;
add_proto qw/void av1_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_1_add/;
add_proto qw/void vp10_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_256_add/;
add_proto qw/void av1_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_256_add/;
add_proto qw/void vp10_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_10_add/;
add_proto qw/void av1_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_10_add/;
add_proto qw/void vp10_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1024_add/;
add_proto qw/void av1_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1024_add/;
add_proto qw/void vp10_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_34_add/;
add_proto qw/void av1_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_34_add/;
add_proto qw/void vp10_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1_add/;
add_proto qw/void av1_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1_add/;
add_proto qw/void vp10_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_1_add/;
add_proto qw/void av1_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_1_add/;
add_proto qw/void vp10_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_16_add/;
add_proto qw/void av1_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_16_add/;
} else {
add_proto qw/void vp10_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_1_add sse2/;
add_proto qw/void av1_idct4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_1_add sse2/;
add_proto qw/void vp10_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct4x4_16_add sse2/;
add_proto qw/void av1_idct4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct4x4_16_add sse2/;
add_proto qw/void vp10_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_1_add sse2/;
add_proto qw/void av1_idct8x8_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_1_add sse2/;
add_proto qw/void vp10_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_64_add sse2/;
add_proto qw/void av1_idct8x8_64_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_64_add sse2/;
add_proto qw/void vp10_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct8x8_12_add sse2/;
add_proto qw/void av1_idct8x8_12_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct8x8_12_add sse2/;
add_proto qw/void vp10_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_1_add sse2/;
add_proto qw/void av1_idct16x16_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_1_add sse2/;
add_proto qw/void vp10_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_256_add sse2/;
add_proto qw/void av1_idct16x16_256_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_256_add sse2/;
add_proto qw/void vp10_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct16x16_10_add sse2/;
add_proto qw/void av1_idct16x16_10_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct16x16_10_add sse2/;
add_proto qw/void vp10_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1024_add sse2/;
add_proto qw/void av1_idct32x32_1024_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1024_add sse2/;
add_proto qw/void vp10_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_34_add sse2/;
add_proto qw/void av1_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_34_add sse2/;
add_proto qw/void vp10_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_idct32x32_1_add sse2/;
add_proto qw/void av1_idct32x32_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_idct32x32_1_add sse2/;
add_proto qw/void vp10_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_1_add/;
add_proto qw/void av1_iwht4x4_1_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_1_add/;
add_proto qw/void vp10_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/vp10_iwht4x4_16_add/;
add_proto qw/void av1_iwht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
specialize qw/av1_iwht4x4_16_add/;
} # CONFIG_EMULATE_HARDWARE
} # CONFIG_VPX_HIGHBITDEPTH
} # CONFIG_AOM_HIGHBITDEPTH
#
# Motion search
#
add_proto qw/int vp10_full_search_sad/, "const struct macroblock *x, const struct mv *ref_mv, int sad_per_bit, int distance, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv, struct mv *best_mv";
specialize qw/vp10_full_search_sad sse3 sse4_1/;
$vp10_full_search_sad_sse3=vp10_full_search_sadx3;
$vp10_full_search_sad_sse4_1=vp10_full_search_sadx8;
add_proto qw/int av1_full_search_sad/, "const struct macroblock *x, const struct mv *ref_mv, int sad_per_bit, int distance, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv, struct mv *best_mv";
specialize qw/av1_full_search_sad sse3 sse4_1/;
$av1_full_search_sad_sse3=av1_full_search_sadx3;
$av1_full_search_sad_sse4_1=av1_full_search_sadx8;
add_proto qw/int vp10_diamond_search_sad/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/vp10_diamond_search_sad/;
add_proto qw/int av1_diamond_search_sad/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/av1_diamond_search_sad/;
add_proto qw/int vp10_full_range_search/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/vp10_full_range_search/;
add_proto qw/int av1_full_range_search/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct aom_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/av1_full_range_search/;
add_proto qw/void vp10_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";
specialize qw/vp10_temporal_filter_apply sse2 msa/;
add_proto qw/void av1_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";
specialize qw/av1_temporal_filter_apply sse2 msa/;
if (aom_config("CONFIG_VPX_HIGHBITDEPTH") eq "yes") {
if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
# ENCODEMB INVOKE
add_proto qw/int64_t vp10_highbd_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd";
specialize qw/vp10_highbd_block_error sse2/;
add_proto qw/int64_t av1_highbd_block_error/, "const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd";
specialize qw/av1_highbd_block_error sse2/;
if (aom_config("CONFIG_AOM_QM") eq "yes") {
add_proto qw/void vp10_highbd_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
add_proto qw/void av1_highbd_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
add_proto qw/void vp10_highbd_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
add_proto qw/void av1_highbd_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr";
} else {
add_proto qw/void vp10_highbd_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_highbd_quantize_fp/;
add_proto qw/void av1_highbd_quantize_fp/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_highbd_quantize_fp/;
add_proto qw/void vp10_highbd_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/vp10_highbd_quantize_fp_32x32/;
add_proto qw/void av1_highbd_quantize_fp_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
specialize qw/av1_highbd_quantize_fp_32x32/;
}
# fdct functions
add_proto qw/void vp10_highbd_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_highbd_fht4x4/;
add_proto qw/void av1_highbd_fht4x4/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_highbd_fht4x4/;
add_proto qw/void vp10_highbd_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_highbd_fht8x8/;
add_proto qw/void av1_highbd_fht8x8/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_highbd_fht8x8/;
add_proto qw/void vp10_highbd_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/vp10_highbd_fht16x16/;
add_proto qw/void av1_highbd_fht16x16/, "const int16_t *input, tran_low_t *output, int stride, int tx_type";
specialize qw/av1_highbd_fht16x16/;
add_proto qw/void vp10_highbd_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/vp10_highbd_fwht4x4/;
add_proto qw/void av1_highbd_fwht4x4/, "const int16_t *input, tran_low_t *output, int stride";
specialize qw/av1_highbd_fwht4x4/;
add_proto qw/void vp10_highbd_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";
specialize qw/vp10_highbd_temporal_filter_apply/;
add_proto qw/void av1_highbd_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";
specialize qw/av1_highbd_temporal_filter_apply/;
}
# End vp10_high encoder functions
# End av1_high encoder functions
}
# end encoder functions

14
av1/common/blockd.c
Просмотреть файл

@ -11,7 +11,7 @@
#include "av1/common/blockd.h"
PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
PREDICTION_MODE av1_left_block_mode(const MODE_INFO *cur_mi,
const MODE_INFO *left_mi, int b) {
if (b == 0 || b == 2) {
if (!left_mi || is_inter_block(&left_mi->mbmi)) return DC_PRED;
@ -23,7 +23,7 @@ PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
}
}
PREDICTION_MODE vp10_above_block_mode(const MODE_INFO *cur_mi,
PREDICTION_MODE av1_above_block_mode(const MODE_INFO *cur_mi,
const MODE_INFO *above_mi, int b) {
if (b == 0 || b == 1) {
if (!above_mi || is_inter_block(&above_mi->mbmi)) return DC_PRED;
@ -35,7 +35,7 @@ PREDICTION_MODE vp10_above_block_mode(const MODE_INFO *cur_mi,
}
}
void vp10_foreach_transformed_block_in_plane(
void av1_foreach_transformed_block_in_plane(
const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
foreach_transformed_block_visitor visit, void *arg) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
@ -74,17 +74,17 @@ void vp10_foreach_transformed_block_in_plane(
}
}
void vp10_foreach_transformed_block(const MACROBLOCKD *const xd,
void av1_foreach_transformed_block(const MACROBLOCKD *const xd,
BLOCK_SIZE bsize,
foreach_transformed_block_visitor visit,
void *arg) {
int plane;
for (plane = 0; plane < MAX_MB_PLANE; ++plane)
vp10_foreach_transformed_block_in_plane(xd, bsize, plane, visit, arg);
av1_foreach_transformed_block_in_plane(xd, bsize, plane, visit, arg);
}
void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
void av1_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
int aoff, int loff) {
ENTROPY_CONTEXT *const a = pd->above_context + aoff;
@ -121,7 +121,7 @@ void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
}
}
void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y) {
void av1_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y) {
int i;
for (i = 0; i < MAX_MB_PLANE; i++) {

22
av1/common/blockd.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_BLOCKD_H_
#define VP10_COMMON_BLOCKD_H_
#ifndef AV1_COMMON_BLOCKD_H_
#define AV1_COMMON_BLOCKD_H_
#include "./aom_config.h"
@ -110,10 +110,10 @@ static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
return mbmi->ref_frame[1] > INTRA_FRAME;
}
PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
PREDICTION_MODE av1_left_block_mode(const MODE_INFO *cur_mi,
const MODE_INFO *left_mi, int b);
PREDICTION_MODE vp10_above_block_mode(const MODE_INFO *cur_mi,
PREDICTION_MODE av1_above_block_mode(const MODE_INFO *cur_mi,
const MODE_INFO *above_mi, int b);
enum mv_precision { MV_PRECISION_Q3, MV_PRECISION_Q4 };
@ -154,7 +154,7 @@ struct macroblockd_plane {
typedef struct RefBuffer {
// TODO(dkovalev): idx is not really required and should be removed, now it
// is used in vp10_onyxd_if.c
// is used in av1_onyxd_if.c
int idx;
YV12_BUFFER_CONFIG *buf;
struct scale_factors sf;
@ -199,7 +199,7 @@ typedef struct macroblockd {
PARTITION_CONTEXT *above_seg_context;
PARTITION_CONTEXT left_seg_context[8];
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
/* Bit depth: 8, 10, 12 */
int bd;
#endif
@ -241,7 +241,7 @@ static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type, const MACROBLOCKD *xd,
return mbmi->tx_type;
}
void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
void av1_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize,
int xss, int yss) {
@ -281,16 +281,16 @@ typedef void (*foreach_transformed_block_visitor)(int plane, int block,
BLOCK_SIZE plane_bsize,
TX_SIZE tx_size, void *arg);
void vp10_foreach_transformed_block_in_plane(
void av1_foreach_transformed_block_in_plane(
const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
foreach_transformed_block_visitor visit, void *arg);
void vp10_foreach_transformed_block(const MACROBLOCKD *const xd,
void av1_foreach_transformed_block(const MACROBLOCKD *const xd,
BLOCK_SIZE bsize,
foreach_transformed_block_visitor visit,
void *arg);
void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
void av1_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
int aoff, int loff);
@ -298,4 +298,4 @@ void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
} // extern "C"
#endif
#endif // VP10_COMMON_BLOCKD_H_
#endif // AV1_COMMON_BLOCKD_H_

12
av1/common/clpf.c
Просмотреть файл

@ -33,8 +33,8 @@ static void clpf_block(const uint8_t *src, uint8_t *dst, int sstride,
#define BS MI_SIZE *MI_BLOCK_SIZE
// Iterate over blocks within a superblock
static void vp10_clpf_sb(const YV12_BUFFER_CONFIG *frame_buffer,
const VP10_COMMON *cm, MACROBLOCKD *xd,
static void av1_clpf_sb(const YV12_BUFFER_CONFIG *frame_buffer,
const AV1_COMMON *cm, MACROBLOCKD *xd,
MODE_INFO *const *mi_8x8, int xpos, int ypos) {
// Temporary buffer (to allow SIMD parallelism)
uint8_t buf_unaligned[BS * BS + 15];
@ -61,7 +61,7 @@ static void vp10_clpf_sb(const YV12_BUFFER_CONFIG *frame_buffer,
has_bottom &= y != MI_BLOCK_SIZE - 1;
has_right &= x != MI_BLOCK_SIZE - 1;
#endif
vp10_setup_dst_planes(xd->plane, frame_buffer, ypos + y, xpos + x);
av1_setup_dst_planes(xd->plane, frame_buffer, ypos + y, xpos + x);
clpf_block(
xd->plane[p].dst.buf, CLPF_ALLOW_PIXEL_PARALLELISM
? buf + y * MI_SIZE * BS + x * MI_SIZE
@ -79,7 +79,7 @@ static void vp10_clpf_sb(const YV12_BUFFER_CONFIG *frame_buffer,
for (x = 0; x < MI_BLOCK_SIZE && xpos + x < cm->mi_cols; x++) {
const MB_MODE_INFO *mbmi =
&mi_8x8[(ypos + y) * cm->mi_stride + xpos + x]->mbmi;
vp10_setup_dst_planes(xd->plane, frame_buffer, ypos + y, xpos + x);
av1_setup_dst_planes(xd->plane, frame_buffer, ypos + y, xpos + x);
if (!mbmi->skip) {
int i = 0;
for (i = 0; i<MI_SIZE>> xd->plane[p].subsampling_y; i++)
@ -94,11 +94,11 @@ static void vp10_clpf_sb(const YV12_BUFFER_CONFIG *frame_buffer,
}
// Iterate over the superblocks of an entire frame
void vp10_clpf_frame(const YV12_BUFFER_CONFIG *frame, const VP10_COMMON *cm,
void av1_clpf_frame(const YV12_BUFFER_CONFIG *frame, const AV1_COMMON *cm,
MACROBLOCKD *xd) {
int x, y;
for (y = 0; y < cm->mi_rows; y += MI_BLOCK_SIZE)
for (x = 0; x < cm->mi_cols; x += MI_BLOCK_SIZE)
vp10_clpf_sb(frame, cm, xd, cm->mi_grid_visible, x, y);
av1_clpf_sb(frame, cm, xd, cm->mi_grid_visible, x, y);
}

6
av1/common/clpf.h
Просмотреть файл

@ -8,8 +8,8 @@
* 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 VP10_COMMON_CLPF_H_
#define VP10_COMMON_CLPF_H_
#ifndef AV1_COMMON_CLPF_H_
#define AV1_COMMON_CLPF_H_
#include "av1/common/reconinter.h"
@ -21,7 +21,7 @@
#define CLPF_FILTER_ALL_PLANES \
0 // 1 = filter both luma and chroma, 0 = filter only luma
void vp10_clpf_frame(const YV12_BUFFER_CONFIG *frame, const VP10_COMMON *cm,
void av1_clpf_frame(const YV12_BUFFER_CONFIG *frame, const AV1_COMMON *cm,
MACROBLOCKD *xd);
#endif

20
av1/common/common.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_COMMON_H_
#define VP10_COMMON_COMMON_H_
#ifndef AV1_COMMON_COMMON_H_
#define AV1_COMMON_COMMON_H_
/* Interface header for common constant data structures and lookup tables */
@ -27,21 +27,21 @@ extern "C" {
#endif
// Only need this for fixed-size arrays, for structs just assign.
#define vp10_copy(dest, src) \
#define av1_copy(dest, src) \
{ \
assert(sizeof(dest) == sizeof(src)); \
memcpy(dest, src, sizeof(src)); \
}
// Use this for variably-sized arrays.
#define vp10_copy_array(dest, src, n) \
#define av1_copy_array(dest, src, n) \
{ \
assert(sizeof(*dest) == sizeof(*src)); \
memcpy(dest, src, n * sizeof(*src)); \
}
#define vp10_zero(dest) memset(&(dest), 0, sizeof(dest))
#define vp10_zero_array(dest, n) memset(dest, 0, n * sizeof(*dest))
#define av1_zero(dest) memset(&(dest), 0, sizeof(dest))
#define av1_zero_array(dest, n) memset(dest, 0, n * sizeof(*dest))
static INLINE int get_unsigned_bits(unsigned int num_values) {
return num_values > 0 ? get_msb(num_values) + 1 : 0;
@ -66,9 +66,9 @@ static INLINE int get_unsigned_bits(unsigned int num_values) {
} while (0)
#endif
// TODO(yaowu: validate the usage of these codes or develop new ones.)
#define VP10_SYNC_CODE_0 0x49
#define VP10_SYNC_CODE_1 0x83
#define VP10_SYNC_CODE_2 0x43
#define AV1_SYNC_CODE_0 0x49
#define AV1_SYNC_CODE_1 0x83
#define AV1_SYNC_CODE_2 0x43
#define VPX_FRAME_MARKER 0x2
@ -76,4 +76,4 @@ static INLINE int get_unsigned_bits(unsigned int num_values) {
} // extern "C"
#endif
#endif // VP10_COMMON_COMMON_H_
#endif // AV1_COMMON_COMMON_H_

6
av1/common/common_data.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_COMMON_DATA_H_
#define VP10_COMMON_COMMON_DATA_H_
#ifndef AV1_COMMON_COMMON_DATA_H_
#define AV1_COMMON_COMMON_DATA_H_
#include "av1/common/enums.h"
#include "aom/aom_integer.h"
@ -175,4 +175,4 @@ static const struct {
} // extern "C"
#endif
#endif // VP10_COMMON_COMMON_DATA_H_
#endif // AV1_COMMON_COMMON_DATA_H_

6
av1/common/debugmodes.c
Просмотреть файл

@ -14,7 +14,7 @@
#include "av1/common/blockd.h"
#include "av1/common/onyxc_int.h"
static void log_frame_info(VP10_COMMON *cm, const char *str, FILE *f) {
static void log_frame_info(AV1_COMMON *cm, const char *str, FILE *f) {
fprintf(f, "%s", str);
fprintf(f, "(Frame %d, Show:%d, Q:%d): \n", cm->current_video_frame,
cm->show_frame, cm->base_qindex);
@ -23,7 +23,7 @@ static void log_frame_info(VP10_COMMON *cm, const char *str, FILE *f) {
* and uses the passed in member offset to print out the value of an integer
* for each mbmi member value in the mi structure.
*/
static void print_mi_data(VP10_COMMON *cm, FILE *file, const char *descriptor,
static void print_mi_data(AV1_COMMON *cm, FILE *file, const char *descriptor,
size_t member_offset) {
int mi_row, mi_col;
MODE_INFO **mi = cm->mi_grid_visible;
@ -44,7 +44,7 @@ static void print_mi_data(VP10_COMMON *cm, FILE *file, const char *descriptor,
fprintf(file, "\n");
}
void vp10_print_modes_and_motion_vectors(VP10_COMMON *cm, const char *file) {
void av1_print_modes_and_motion_vectors(AV1_COMMON *cm, const char *file) {
int mi_row;
int mi_col;
FILE *mvs = fopen(file, "a");

14
av1/common/dering.c
Просмотреть файл

@ -28,7 +28,7 @@ int compute_level_from_index(int global_level, int gi) {
return clamp(level, gi, MAX_DERING_LEVEL-1);
}
int sb_all_skip(const VP10_COMMON *const cm, int mi_row, int mi_col) {
int sb_all_skip(const AV1_COMMON *const cm, int mi_row, int mi_col) {
int r, c;
int maxc, maxr;
int skip = 1;
@ -46,7 +46,7 @@ int sb_all_skip(const VP10_COMMON *const cm, int mi_row, int mi_col) {
return skip;
}
void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
void av1_dering_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
MACROBLOCKD *xd, int global_level) {
int r, c;
int sbr, sbc;
@ -62,7 +62,7 @@ void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
nvsb = (cm->mi_rows + MI_BLOCK_SIZE - 1)/MI_BLOCK_SIZE;
nhsb = (cm->mi_cols + MI_BLOCK_SIZE - 1)/MI_BLOCK_SIZE;
bskip = aom_malloc(sizeof(*bskip)*cm->mi_rows*cm->mi_cols);
vp10_setup_dst_planes(xd->plane, frame, 0, 0);
av1_setup_dst_planes(xd->plane, frame, 0, 0);
for (pli = 0; pli < 3; pli++) {
dec[pli] = xd->plane[pli].subsampling_x;
bsize[pli] = 8 >> dec[pli];
@ -72,7 +72,7 @@ void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
src[pli] = aom_malloc(sizeof(*src)*cm->mi_rows*cm->mi_cols*64);
for (r = 0; r < bsize[pli]*cm->mi_rows; ++r) {
for (c = 0; c < bsize[pli]*cm->mi_cols; ++c) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
src[pli][r * stride + c] =
CONVERT_TO_SHORTPTR(xd->plane[pli].dst.buf)
@ -81,7 +81,7 @@ void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
#endif
src[pli][r * stride + c] =
xd->plane[pli].dst.buf[r * xd->plane[pli].dst.stride + c];
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
}
#endif
}
@ -127,7 +127,7 @@ void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
cm->mi_cols, threshold, OD_DERING_NO_CHECK_OVERLAP, coeff_shift);
for (r = 0; r < bsize[pli]*nvb; ++r) {
for (c = 0; c < bsize[pli]*nhb; ++c) {
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
CONVERT_TO_SHORTPTR(xd->plane[pli].dst.buf)
[xd->plane[pli].dst.stride*(bsize[pli]*MI_BLOCK_SIZE*sbr + r)
@ -139,7 +139,7 @@ void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
(bsize[pli]*MI_BLOCK_SIZE*sbr + r) +
sbc*bsize[pli]*MI_BLOCK_SIZE + c] =
dst[r * MI_BLOCK_SIZE * bsize[pli] + c];
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
}
#endif
}

14
av1/common/dering.h
Просмотреть файл

@ -8,8 +8,8 @@
* 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 VP10_COMMON_DERING_H_
#define VP10_COMMON_DERING_H_
#ifndef AV1_COMMON_DERING_H_
#define AV1_COMMON_DERING_H_
#include "av1/common/od_dering.h"
#include "av1/common/onyxc_int.h"
@ -29,15 +29,15 @@ extern "C" {
#define DERING_REFINEMENT_LEVELS 4
int compute_level_from_index(int global_level, int gi);
int sb_all_skip(const VP10_COMMON *const cm, int mi_row, int mi_col);
void vp10_dering_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
int sb_all_skip(const AV1_COMMON *const cm, int mi_row, int mi_col);
void av1_dering_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
MACROBLOCKD *xd, int global_level);
int vp10_dering_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref,
VP10_COMMON *cm,
int av1_dering_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref,
AV1_COMMON *cm,
MACROBLOCKD *xd);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_DERING_H_
#endif // AV1_COMMON_DERING_H_

84
av1/common/entropy.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "aom/aom_integer.h"
// Unconstrained Node Tree
const aom_tree_index vp10_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)] = {
const aom_tree_index av1_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)] = {
2,
6, // 0 = LOW_VAL
-TWO_TOKEN,
@ -36,33 +36,33 @@ const aom_tree_index vp10_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)] = {
-CATEGORY6_TOKEN // 7 = CAT_FIVE
};
const aom_prob vp10_cat1_prob[] = { 159 };
const aom_prob vp10_cat2_prob[] = { 165, 145 };
const aom_prob vp10_cat3_prob[] = { 173, 148, 140 };
const aom_prob vp10_cat4_prob[] = { 176, 155, 140, 135 };
const aom_prob vp10_cat5_prob[] = { 180, 157, 141, 134, 130 };
const aom_prob vp10_cat6_prob[] = { 254, 254, 254, 252, 249, 243, 230,
const aom_prob av1_cat1_prob[] = { 159 };
const aom_prob av1_cat2_prob[] = { 165, 145 };
const aom_prob av1_cat3_prob[] = { 173, 148, 140 };
const aom_prob av1_cat4_prob[] = { 176, 155, 140, 135 };
const aom_prob av1_cat5_prob[] = { 180, 157, 141, 134, 130 };
const aom_prob av1_cat6_prob[] = { 254, 254, 254, 252, 249, 243, 230,
196, 177, 153, 140, 133, 130, 129 };
#if CONFIG_VPX_HIGHBITDEPTH
const aom_prob vp10_cat1_prob_high10[] = { 159 };
const aom_prob vp10_cat2_prob_high10[] = { 165, 145 };
const aom_prob vp10_cat3_prob_high10[] = { 173, 148, 140 };
const aom_prob vp10_cat4_prob_high10[] = { 176, 155, 140, 135 };
const aom_prob vp10_cat5_prob_high10[] = { 180, 157, 141, 134, 130 };
const aom_prob vp10_cat6_prob_high10[] = {
#if CONFIG_AOM_HIGHBITDEPTH
const aom_prob av1_cat1_prob_high10[] = { 159 };
const aom_prob av1_cat2_prob_high10[] = { 165, 145 };
const aom_prob av1_cat3_prob_high10[] = { 173, 148, 140 };
const aom_prob av1_cat4_prob_high10[] = { 176, 155, 140, 135 };
const aom_prob av1_cat5_prob_high10[] = { 180, 157, 141, 134, 130 };
const aom_prob av1_cat6_prob_high10[] = {
255, 255, 254, 254, 254, 252, 249, 243, 230, 196, 177, 153, 140, 133, 130, 129
};
const aom_prob vp10_cat1_prob_high12[] = { 159 };
const aom_prob vp10_cat2_prob_high12[] = { 165, 145 };
const aom_prob vp10_cat3_prob_high12[] = { 173, 148, 140 };
const aom_prob vp10_cat4_prob_high12[] = { 176, 155, 140, 135 };
const aom_prob vp10_cat5_prob_high12[] = { 180, 157, 141, 134, 130 };
const aom_prob vp10_cat6_prob_high12[] = { 255, 255, 255, 255, 254, 254,
const aom_prob av1_cat1_prob_high12[] = { 159 };
const aom_prob av1_cat2_prob_high12[] = { 165, 145 };
const aom_prob av1_cat3_prob_high12[] = { 173, 148, 140 };
const aom_prob av1_cat4_prob_high12[] = { 176, 155, 140, 135 };
const aom_prob av1_cat5_prob_high12[] = { 180, 157, 141, 134, 130 };
const aom_prob av1_cat6_prob_high12[] = { 255, 255, 255, 255, 254, 254,
254, 252, 249, 243, 230, 196,
177, 153, 140, 133, 130, 129 };
#endif
const uint8_t vp10_coefband_trans_8x8plus[1024] = {
const uint8_t av1_coefband_trans_8x8plus[1024] = {
0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5,
// beyond MAXBAND_INDEX+1 all values are filled as 5
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
@ -106,11 +106,11 @@ const uint8_t vp10_coefband_trans_8x8plus[1024] = {
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
};
const uint8_t vp10_coefband_trans_4x4[16] = {
const uint8_t av1_coefband_trans_4x4[16] = {
0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5,
};
const uint8_t vp10_pt_energy_class[ENTROPY_TOKENS] = { 0, 1, 2, 3, 3, 4,
const uint8_t av1_pt_energy_class[ENTROPY_TOKENS] = { 0, 1, 2, 3, 3, 4,
4, 5, 5, 5, 5, 5 };
// Model obtained from a 2-sided zero-centerd distribuition derived
@ -125,9 +125,9 @@ const uint8_t vp10_pt_energy_class[ENTROPY_TOKENS] = { 0, 1, 2, 3, 3, 4,
// Every odd line in this table can be generated from the even lines
// by averaging :
// vp10_pareto8_full[l][node] = (vp10_pareto8_full[l-1][node] +
// vp10_pareto8_full[l+1][node] ) >> 1;
const aom_prob vp10_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES] = {
// av1_pareto8_full[l][node] = (av1_pareto8_full[l-1][node] +
// av1_pareto8_full[l+1][node] ) >> 1;
const aom_prob av1_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES] = {
{ 3, 86, 128, 6, 86, 23, 88, 29 },
{ 6, 86, 128, 11, 87, 42, 91, 52 },
{ 9, 86, 129, 17, 88, 61, 94, 76 },
@ -385,7 +385,7 @@ const aom_prob vp10_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES] = {
{ 255, 246, 247, 255, 239, 255, 253, 255 },
};
static const vp10_coeff_probs_model default_coef_probs_4x4[PLANE_TYPES] = {
static const av1_coeff_probs_model default_coef_probs_4x4[PLANE_TYPES] = {
{ // Y plane
{ // Intra
{ // Band 0
@ -550,7 +550,7 @@ static const vp10_coeff_probs_model default_coef_probs_4x4[PLANE_TYPES] = {
{ 8, 23, 61 } } } }
};
static const vp10_coeff_probs_model default_coef_probs_8x8[PLANE_TYPES] = {
static const av1_coeff_probs_model default_coef_probs_8x8[PLANE_TYPES] = {
{ // Y plane
{ // Intra
{ // Band 0
@ -715,7 +715,7 @@ static const vp10_coeff_probs_model default_coef_probs_8x8[PLANE_TYPES] = {
{ 1, 23, 41 } } } }
};
static const vp10_coeff_probs_model default_coef_probs_16x16[PLANE_TYPES] = {
static const av1_coeff_probs_model default_coef_probs_16x16[PLANE_TYPES] = {
{ // Y plane
{ // Intra
{ // Band 0
@ -880,7 +880,7 @@ static const vp10_coeff_probs_model default_coef_probs_16x16[PLANE_TYPES] = {
{ 1, 17, 31 } } } }
};
static const vp10_coeff_probs_model default_coef_probs_32x32[PLANE_TYPES] = {
static const av1_coeff_probs_model default_coef_probs_32x32[PLANE_TYPES] = {
{ // Y plane
{ // Intra
{ // Band 0
@ -1048,21 +1048,21 @@ static const vp10_coeff_probs_model default_coef_probs_32x32[PLANE_TYPES] = {
static void extend_to_full_distribution(aom_prob *probs, aom_prob p) {
// TODO(aconverse): model[PIVOT_NODE] should never be zero.
// https://code.google.com/p/webm/issues/detail?id=1089
memcpy(probs, vp10_pareto8_full[p == 0 ? 254 : p - 1],
memcpy(probs, av1_pareto8_full[p == 0 ? 254 : p - 1],
MODEL_NODES * sizeof(aom_prob));
}
void vp10_model_to_full_probs(const aom_prob *model, aom_prob *full) {
void av1_model_to_full_probs(const aom_prob *model, aom_prob *full) {
if (full != model)
memcpy(full, model, sizeof(aom_prob) * UNCONSTRAINED_NODES);
extend_to_full_distribution(&full[UNCONSTRAINED_NODES], model[PIVOT_NODE]);
}
void vp10_default_coef_probs(VP10_COMMON *cm) {
vp10_copy(cm->fc->coef_probs[TX_4X4], default_coef_probs_4x4);
vp10_copy(cm->fc->coef_probs[TX_8X8], default_coef_probs_8x8);
vp10_copy(cm->fc->coef_probs[TX_16X16], default_coef_probs_16x16);
vp10_copy(cm->fc->coef_probs[TX_32X32], default_coef_probs_32x32);
void av1_default_coef_probs(AV1_COMMON *cm) {
av1_copy(cm->fc->coef_probs[TX_4X4], default_coef_probs_4x4);
av1_copy(cm->fc->coef_probs[TX_8X8], default_coef_probs_8x8);
av1_copy(cm->fc->coef_probs[TX_16X16], default_coef_probs_16x16);
av1_copy(cm->fc->coef_probs[TX_32X32], default_coef_probs_32x32);
}
#define COEF_COUNT_SAT 24
@ -1072,13 +1072,13 @@ void vp10_default_coef_probs(VP10_COMMON *cm) {
#define COEF_COUNT_SAT_AFTER_KEY 24
#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY 128
static void adapt_coef_probs(VP10_COMMON *cm, TX_SIZE tx_size,
static void adapt_coef_probs(AV1_COMMON *cm, TX_SIZE tx_size,
unsigned int count_sat,
unsigned int update_factor) {
const FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
vp10_coeff_probs_model *const probs = cm->fc->coef_probs[tx_size];
const vp10_coeff_probs_model *const pre_probs = pre_fc->coef_probs[tx_size];
vp10_coeff_count_model *counts = cm->counts.coef[tx_size];
av1_coeff_probs_model *const probs = cm->fc->coef_probs[tx_size];
const av1_coeff_probs_model *const pre_probs = pre_fc->coef_probs[tx_size];
av1_coeff_count_model *counts = cm->counts.coef[tx_size];
unsigned int(*eob_counts)[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS] =
cm->counts.eob_branch[tx_size];
int i, j, k, l, m;
@ -1101,7 +1101,7 @@ static void adapt_coef_probs(VP10_COMMON *cm, TX_SIZE tx_size,
}
}
void vp10_adapt_coef_probs(VP10_COMMON *cm) {
void av1_adapt_coef_probs(AV1_COMMON *cm) {
TX_SIZE t;
unsigned int count_sat, update_factor;

92
av1/common/entropy.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ENTROPY_H_
#define VP10_COMMON_ENTROPY_H_
#ifndef AV1_COMMON_ENTROPY_H_
#define AV1_COMMON_ENTROPY_H_
#include "aom/aom_integer.h"
#include "aom_dsp/prob.h"
@ -43,7 +43,7 @@ extern "C" {
#define ENTROPY_NODES 11
DECLARE_ALIGNED(16, extern const uint8_t, vp10_pt_energy_class[ENTROPY_TOKENS]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_pt_energy_class[ENTROPY_TOKENS]);
#define CAT1_MIN_VAL 5
#define CAT2_MIN_VAL 7
@ -53,27 +53,27 @@ DECLARE_ALIGNED(16, extern const uint8_t, vp10_pt_energy_class[ENTROPY_TOKENS]);
#define CAT6_MIN_VAL 67
// Extra bit probabilities.
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat1_prob[1]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat2_prob[2]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat3_prob[3]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat4_prob[4]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat5_prob[5]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat6_prob[14]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob[1]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob[2]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob[3]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob[4]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob[5]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob[14]);
#if CONFIG_VPX_HIGHBITDEPTH
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat1_prob_high10[1]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat2_prob_high10[2]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat3_prob_high10[3]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat4_prob_high10[4]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat5_prob_high10[5]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat6_prob_high10[16]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat1_prob_high12[1]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat2_prob_high12[2]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat3_prob_high12[3]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat4_prob_high12[4]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat5_prob_high12[5]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_cat6_prob_high12[18]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob_high10[1]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob_high10[2]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob_high10[3]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob_high10[4]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob_high10[5]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob_high10[16]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob_high12[1]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob_high12[2]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob_high12[3]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob_high12[4]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob_high12[5]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob_high12[18]);
#endif // CONFIG_AOM_HIGHBITDEPTH
#define EOB_MODEL_TOKEN 3
@ -83,20 +83,20 @@ typedef struct {
int len;
int base_val;
const int16_t *cost;
} vp10_extra_bit;
} av1_extra_bit;
// indexed by token value
extern const vp10_extra_bit vp10_extra_bits[ENTROPY_TOKENS];
#if CONFIG_VPX_HIGHBITDEPTH
extern const vp10_extra_bit vp10_extra_bits_high10[ENTROPY_TOKENS];
extern const vp10_extra_bit vp10_extra_bits_high12[ENTROPY_TOKENS];
#endif // CONFIG_VPX_HIGHBITDEPTH
extern const av1_extra_bit av1_extra_bits[ENTROPY_TOKENS];
#if CONFIG_AOM_HIGHBITDEPTH
extern const av1_extra_bit av1_extra_bits_high10[ENTROPY_TOKENS];
extern const av1_extra_bit av1_extra_bits_high12[ENTROPY_TOKENS];
#endif // CONFIG_AOM_HIGHBITDEPTH
#define DCT_MAX_VALUE 16384
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
#define DCT_MAX_VALUE_HIGH10 65536
#define DCT_MAX_VALUE_HIGH12 262144
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
/* Coefficients are predicted via a 3-dimensional probability table. */
@ -127,28 +127,28 @@ extern const vp10_extra_bit vp10_extra_bits_high12[ENTROPY_TOKENS];
// #define ENTROPY_STATS
typedef unsigned int
vp10_coeff_count[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_TOKENS];
av1_coeff_count[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_TOKENS];
typedef unsigned int
vp10_coeff_stats[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_NODES][2];
av1_coeff_stats[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_NODES][2];
#define SUBEXP_PARAM 4 /* Subexponential code parameter */
#define MODULUS_PARAM 13 /* Modulus parameter */
struct VP10Common;
void vp10_default_coef_probs(struct VP10Common *cm);
void vp10_adapt_coef_probs(struct VP10Common *cm);
struct AV1Common;
void av1_default_coef_probs(struct AV1Common *cm);
void av1_adapt_coef_probs(struct AV1Common *cm);
// This is the index in the scan order beyond which all coefficients for
// 8x8 transform and above are in the top band.
// This macro is currently unused but may be used by certain implementations
#define MAXBAND_INDEX 21
DECLARE_ALIGNED(16, extern const uint8_t, vp10_coefband_trans_8x8plus[1024]);
DECLARE_ALIGNED(16, extern const uint8_t, vp10_coefband_trans_4x4[16]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_coefband_trans_8x8plus[1024]);
DECLARE_ALIGNED(16, extern const uint8_t, av1_coefband_trans_4x4[16]);
static INLINE const uint8_t *get_band_translate(TX_SIZE tx_size) {
return tx_size == TX_4X4 ? vp10_coefband_trans_4x4
: vp10_coefband_trans_8x8plus;
return tx_size == TX_4X4 ? av1_coefband_trans_4x4
: av1_coefband_trans_8x8plus;
}
// 128 lists of probabilities are stored for the following ONE node probs:
@ -162,16 +162,16 @@ static INLINE const uint8_t *get_band_translate(TX_SIZE tx_size) {
#define PIVOT_NODE 2 // which node is pivot
#define MODEL_NODES (ENTROPY_NODES - UNCONSTRAINED_NODES)
extern const aom_tree_index vp10_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)];
extern const aom_prob vp10_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES];
extern const aom_tree_index av1_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)];
extern const aom_prob av1_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES];
typedef aom_prob vp10_coeff_probs_model[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS]
typedef aom_prob av1_coeff_probs_model[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS]
[UNCONSTRAINED_NODES];
typedef unsigned int vp10_coeff_count_model
typedef unsigned int av1_coeff_count_model
[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1];
void vp10_model_to_full_probs(const aom_prob *model, aom_prob *full);
void av1_model_to_full_probs(const aom_prob *model, aom_prob *full);
typedef char ENTROPY_CONTEXT;
@ -211,4 +211,4 @@ static INLINE int get_entropy_context(TX_SIZE tx_size, const ENTROPY_CONTEXT *a,
} // extern "C"
#endif
#endif // VP10_COMMON_ENTROPY_H_
#endif // AV1_COMMON_ENTROPY_H_

94
av1/common/entropymode.c
Просмотреть файл

@ -14,7 +14,7 @@
#include "av1/common/onyxc_int.h"
#include "av1/common/seg_common.h"
const aom_prob vp10_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1] =
const aom_prob av1_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1] =
{ {
// above = dc
{ 137, 30, 42, 148, 151, 207, 70, 52, 91 }, // left = dc
@ -147,7 +147,7 @@ const aom_prob vp10_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1] =
} };
#if !CONFIG_MISC_FIXES
const aom_prob vp10_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1] = {
const aom_prob av1_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1] = {
{ 144, 11, 54, 157, 195, 130, 46, 58, 108 }, // y = dc
{ 118, 15, 123, 148, 131, 101, 44, 93, 131 }, // y = v
{ 113, 12, 23, 188, 226, 142, 26, 32, 125 }, // y = h
@ -183,7 +183,7 @@ static const aom_prob default_uv_probs[INTRA_MODES][INTRA_MODES - 1] = {
#if !CONFIG_MISC_FIXES
const aom_prob
vp10_kf_partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1] = {
av1_kf_partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1] = {
// 8x8 -> 4x4
{ 158, 97, 94 }, // a/l both not split
{ 93, 24, 99 }, // a split, l not split
@ -243,7 +243,7 @@ static const aom_prob
};
/* Array indices are identical to previously-existing INTRAMODECONTEXTNODES. */
const aom_tree_index vp10_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
-DC_PRED, 2, /* 0 = DC_NODE */
-TM_PRED, 4, /* 1 = TM_NODE */
-V_PRED, 6, /* 2 = V_NODE */
@ -255,12 +255,12 @@ const aom_tree_index vp10_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
-D153_PRED, -D207_PRED /* 8 = D153_NODE */
};
const aom_tree_index vp10_inter_mode_tree[TREE_SIZE(INTER_MODES)] = {
const aom_tree_index av1_inter_mode_tree[TREE_SIZE(INTER_MODES)] = {
-INTER_OFFSET(ZEROMV), 2, -INTER_OFFSET(NEARESTMV), 4, -INTER_OFFSET(NEARMV),
-INTER_OFFSET(NEWMV)
};
const aom_tree_index vp10_partition_tree[TREE_SIZE(PARTITION_TYPES)] = {
const aom_tree_index av1_partition_tree[TREE_SIZE(PARTITION_TYPES)] = {
-PARTITION_NONE, 2, -PARTITION_HORZ, 4, -PARTITION_VERT, -PARTITION_SPLIT
};
@ -286,7 +286,7 @@ static const struct tx_probs default_tx_probs = { { { 3, 136, 37 },
{ { 100 }, { 66 } } };
void vp10_tx_counts_to_branch_counts_32x32(const unsigned int *tx_count_32x32p,
void av1_tx_counts_to_branch_counts_32x32(const unsigned int *tx_count_32x32p,
unsigned int (*ct_32x32p)[2]) {
ct_32x32p[0][0] = tx_count_32x32p[TX_4X4];
ct_32x32p[0][1] = tx_count_32x32p[TX_8X8] + tx_count_32x32p[TX_16X16] +
@ -297,7 +297,7 @@ void vp10_tx_counts_to_branch_counts_32x32(const unsigned int *tx_count_32x32p,
ct_32x32p[2][1] = tx_count_32x32p[TX_32X32];
}
void vp10_tx_counts_to_branch_counts_16x16(const unsigned int *tx_count_16x16p,
void av1_tx_counts_to_branch_counts_16x16(const unsigned int *tx_count_16x16p,
unsigned int (*ct_16x16p)[2]) {
ct_16x16p[0][0] = tx_count_16x16p[TX_4X4];
ct_16x16p[0][1] = tx_count_16x16p[TX_8X8] + tx_count_16x16p[TX_16X16];
@ -305,7 +305,7 @@ void vp10_tx_counts_to_branch_counts_16x16(const unsigned int *tx_count_16x16p,
ct_16x16p[1][1] = tx_count_16x16p[TX_16X16];
}
void vp10_tx_counts_to_branch_counts_8x8(const unsigned int *tx_count_8x8p,
void av1_tx_counts_to_branch_counts_8x8(const unsigned int *tx_count_8x8p,
unsigned int (*ct_8x8p)[2]) {
ct_8x8p[0][0] = tx_count_8x8p[TX_4X4];
ct_8x8p[0][1] = tx_count_8x8p[TX_8X8];
@ -325,7 +325,7 @@ static const struct segmentation_probs default_seg_probs = {
};
#endif
const aom_tree_index vp10_ext_tx_tree[TREE_SIZE(TX_TYPES)] = {
const aom_tree_index av1_ext_tx_tree[TREE_SIZE(TX_TYPES)] = {
-DCT_DCT, 2, -ADST_ADST, 4, -ADST_DCT, -DCT_ADST
};
@ -341,29 +341,29 @@ static const aom_prob default_inter_ext_tx_prob[EXT_TX_SIZES][TX_TYPES - 1] = {
};
static void init_mode_probs(FRAME_CONTEXT *fc) {
vp10_copy(fc->uv_mode_prob, default_uv_probs);
vp10_copy(fc->y_mode_prob, default_if_y_probs);
vp10_copy(fc->switchable_interp_prob, default_switchable_interp_prob);
vp10_copy(fc->partition_prob, default_partition_probs);
vp10_copy(fc->intra_inter_prob, default_intra_inter_p);
vp10_copy(fc->comp_inter_prob, default_comp_inter_p);
vp10_copy(fc->comp_ref_prob, default_comp_ref_p);
vp10_copy(fc->single_ref_prob, default_single_ref_p);
av1_copy(fc->uv_mode_prob, default_uv_probs);
av1_copy(fc->y_mode_prob, default_if_y_probs);
av1_copy(fc->switchable_interp_prob, default_switchable_interp_prob);
av1_copy(fc->partition_prob, default_partition_probs);
av1_copy(fc->intra_inter_prob, default_intra_inter_p);
av1_copy(fc->comp_inter_prob, default_comp_inter_p);
av1_copy(fc->comp_ref_prob, default_comp_ref_p);
av1_copy(fc->single_ref_prob, default_single_ref_p);
fc->tx_probs = default_tx_probs;
vp10_copy(fc->skip_probs, default_skip_probs);
vp10_copy(fc->inter_mode_probs, default_inter_mode_probs);
av1_copy(fc->skip_probs, default_skip_probs);
av1_copy(fc->inter_mode_probs, default_inter_mode_probs);
#if CONFIG_MISC_FIXES
vp10_copy(fc->seg.tree_probs, default_seg_probs.tree_probs);
vp10_copy(fc->seg.pred_probs, default_seg_probs.pred_probs);
av1_copy(fc->seg.tree_probs, default_seg_probs.tree_probs);
av1_copy(fc->seg.pred_probs, default_seg_probs.pred_probs);
#endif
vp10_copy(fc->intra_ext_tx_prob, default_intra_ext_tx_prob);
vp10_copy(fc->inter_ext_tx_prob, default_inter_ext_tx_prob);
av1_copy(fc->intra_ext_tx_prob, default_intra_ext_tx_prob);
av1_copy(fc->inter_ext_tx_prob, default_inter_ext_tx_prob);
}
const aom_tree_index vp10_switchable_interp_tree[TREE_SIZE(
const aom_tree_index av1_switchable_interp_tree[TREE_SIZE(
SWITCHABLE_FILTERS)] = { -EIGHTTAP, 2, -EIGHTTAP_SMOOTH, -EIGHTTAP_SHARP };
void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
void av1_adapt_inter_frame_probs(AV1_COMMON *cm) {
int i, j;
FRAME_CONTEXT *fc = cm->fc;
const FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
@ -384,32 +384,32 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
pre_fc->single_ref_prob[i][j], counts->single_ref[i][j]);
for (i = 0; i < INTER_MODE_CONTEXTS; i++)
aom_tree_merge_probs(vp10_inter_mode_tree, pre_fc->inter_mode_probs[i],
aom_tree_merge_probs(av1_inter_mode_tree, pre_fc->inter_mode_probs[i],
counts->inter_mode[i], fc->inter_mode_probs[i]);
for (i = 0; i < BLOCK_SIZE_GROUPS; i++)
aom_tree_merge_probs(vp10_intra_mode_tree, pre_fc->y_mode_prob[i],
aom_tree_merge_probs(av1_intra_mode_tree, pre_fc->y_mode_prob[i],
counts->y_mode[i], fc->y_mode_prob[i]);
#if !CONFIG_MISC_FIXES
for (i = 0; i < INTRA_MODES; ++i)
aom_tree_merge_probs(vp10_intra_mode_tree, pre_fc->uv_mode_prob[i],
aom_tree_merge_probs(av1_intra_mode_tree, pre_fc->uv_mode_prob[i],
counts->uv_mode[i], fc->uv_mode_prob[i]);
for (i = 0; i < PARTITION_CONTEXTS; i++)
aom_tree_merge_probs(vp10_partition_tree, pre_fc->partition_prob[i],
aom_tree_merge_probs(av1_partition_tree, pre_fc->partition_prob[i],
counts->partition[i], fc->partition_prob[i]);
#endif
if (cm->interp_filter == SWITCHABLE) {
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
aom_tree_merge_probs(
vp10_switchable_interp_tree, pre_fc->switchable_interp_prob[i],
av1_switchable_interp_tree, pre_fc->switchable_interp_prob[i],
counts->switchable_interp[i], fc->switchable_interp_prob[i]);
}
}
void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
void av1_adapt_intra_frame_probs(AV1_COMMON *cm) {
int i;
FRAME_CONTEXT *fc = cm->fc;
const FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
@ -422,18 +422,18 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
unsigned int branch_ct_32x32p[TX_SIZES - 1][2];
for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
vp10_tx_counts_to_branch_counts_8x8(counts->tx.p8x8[i], branch_ct_8x8p);
av1_tx_counts_to_branch_counts_8x8(counts->tx.p8x8[i], branch_ct_8x8p);
for (j = 0; j < TX_SIZES - 3; ++j)
fc->tx_probs.p8x8[i][j] =
mode_mv_merge_probs(pre_fc->tx_probs.p8x8[i][j], branch_ct_8x8p[j]);
vp10_tx_counts_to_branch_counts_16x16(counts->tx.p16x16[i],
av1_tx_counts_to_branch_counts_16x16(counts->tx.p16x16[i],
branch_ct_16x16p);
for (j = 0; j < TX_SIZES - 2; ++j)
fc->tx_probs.p16x16[i][j] = mode_mv_merge_probs(
pre_fc->tx_probs.p16x16[i][j], branch_ct_16x16p[j]);
vp10_tx_counts_to_branch_counts_32x32(counts->tx.p32x32[i],
av1_tx_counts_to_branch_counts_32x32(counts->tx.p32x32[i],
branch_ct_32x32p);
for (j = 0; j < TX_SIZES - 1; ++j)
fc->tx_probs.p32x32[i][j] = mode_mv_merge_probs(
@ -448,12 +448,12 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
int j;
for (j = 0; j < TX_TYPES; ++j)
aom_tree_merge_probs(vp10_ext_tx_tree, pre_fc->intra_ext_tx_prob[i][j],
aom_tree_merge_probs(av1_ext_tx_tree, pre_fc->intra_ext_tx_prob[i][j],
counts->intra_ext_tx[i][j],
fc->intra_ext_tx_prob[i][j]);
}
for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
aom_tree_merge_probs(vp10_ext_tx_tree, pre_fc->inter_ext_tx_prob[i],
aom_tree_merge_probs(av1_ext_tx_tree, pre_fc->inter_ext_tx_prob[i],
counts->inter_ext_tx[i], fc->inter_ext_tx_prob[i]);
}
@ -463,19 +463,19 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
fc->seg.pred_probs[i] =
mode_mv_merge_probs(pre_fc->seg.pred_probs[i], counts->seg.pred[i]);
aom_tree_merge_probs(vp10_segment_tree, pre_fc->seg.tree_probs,
aom_tree_merge_probs(av1_segment_tree, pre_fc->seg.tree_probs,
counts->seg.tree_mispred, fc->seg.tree_probs);
} else {
aom_tree_merge_probs(vp10_segment_tree, pre_fc->seg.tree_probs,
aom_tree_merge_probs(av1_segment_tree, pre_fc->seg.tree_probs,
counts->seg.tree_total, fc->seg.tree_probs);
}
for (i = 0; i < INTRA_MODES; ++i)
aom_tree_merge_probs(vp10_intra_mode_tree, pre_fc->uv_mode_prob[i],
aom_tree_merge_probs(av1_intra_mode_tree, pre_fc->uv_mode_prob[i],
counts->uv_mode[i], fc->uv_mode_prob[i]);
for (i = 0; i < PARTITION_CONTEXTS; i++)
aom_tree_merge_probs(vp10_partition_tree, pre_fc->partition_prob[i],
aom_tree_merge_probs(av1_partition_tree, pre_fc->partition_prob[i],
counts->partition[i], fc->partition_prob[i]);
#endif
}
@ -493,13 +493,13 @@ static void set_default_lf_deltas(struct loopfilter *lf) {
lf->mode_deltas[1] = 0;
}
void vp10_setup_past_independence(VP10_COMMON *cm) {
void av1_setup_past_independence(AV1_COMMON *cm) {
// Reset the segment feature data to the default stats:
// Features disabled, 0, with delta coding (Default state).
struct loopfilter *const lf = &cm->lf;
int i;
vp10_clearall_segfeatures(&cm->seg);
av1_clearall_segfeatures(&cm->seg);
cm->seg.abs_delta = SEGMENT_DELTADATA;
if (cm->last_frame_seg_map && !cm->frame_parallel_decode)
@ -509,16 +509,16 @@ void vp10_setup_past_independence(VP10_COMMON *cm) {
memset(cm->current_frame_seg_map, 0, (cm->mi_rows * cm->mi_cols));
// Reset the mode ref deltas for loop filter
vp10_zero(lf->last_ref_deltas);
vp10_zero(lf->last_mode_deltas);
av1_zero(lf->last_ref_deltas);
av1_zero(lf->last_mode_deltas);
set_default_lf_deltas(lf);
// To force update of the sharpness
lf->last_sharpness_level = -1;
vp10_default_coef_probs(cm);
av1_default_coef_probs(cm);
init_mode_probs(cm->fc);
vp10_init_mv_probs(cm);
av1_init_mv_probs(cm);
cm->fc->initialized = 1;
if (cm->frame_type == KEY_FRAME || cm->error_resilient_mode ||

42
av1/common/entropymode.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ENTROPYMODE_H_
#define VP10_COMMON_ENTROPYMODE_H_
#ifndef AV1_COMMON_ENTROPYMODE_H_
#define AV1_COMMON_ENTROPYMODE_H_
#include "av1/common/entropy.h"
#include "av1/common/entropymv.h"
@ -28,7 +28,7 @@ extern "C" {
#define INTER_OFFSET(mode) ((mode)-NEARESTMV)
struct VP10Common;
struct AV1Common;
struct tx_probs {
aom_prob p32x32[TX_SIZE_CONTEXTS][TX_SIZES - 1];
@ -53,7 +53,7 @@ typedef struct frame_contexts {
aom_prob y_mode_prob[BLOCK_SIZE_GROUPS][INTRA_MODES - 1];
aom_prob uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
aom_prob partition_prob[PARTITION_CONTEXTS][PARTITION_TYPES - 1];
vp10_coeff_probs_model coef_probs[TX_SIZES][PLANE_TYPES];
av1_coeff_probs_model coef_probs[TX_SIZES][PLANE_TYPES];
aom_prob
switchable_interp_prob[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS -
1];
@ -78,7 +78,7 @@ typedef struct FRAME_COUNTS {
unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
unsigned int uv_mode[INTRA_MODES][INTRA_MODES];
unsigned int partition[PARTITION_CONTEXTS][PARTITION_TYPES];
vp10_coeff_count_model coef[TX_SIZES][PLANE_TYPES];
av1_coeff_count_model coef[TX_SIZES][PLANE_TYPES];
unsigned int
eob_branch[TX_SIZES][PLANE_TYPES][REF_TYPES][COEF_BANDS][COEFF_CONTEXTS];
unsigned int
@ -99,34 +99,34 @@ typedef struct FRAME_COUNTS {
} FRAME_COUNTS;
extern const aom_prob
vp10_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1];
av1_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1];
#if !CONFIG_MISC_FIXES
extern const aom_prob vp10_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
extern const aom_prob av1_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
extern const aom_prob
vp10_kf_partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1];
av1_kf_partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1];
#endif
extern const aom_tree_index vp10_intra_mode_tree[TREE_SIZE(INTRA_MODES)];
extern const aom_tree_index vp10_inter_mode_tree[TREE_SIZE(INTER_MODES)];
extern const aom_tree_index vp10_partition_tree[TREE_SIZE(PARTITION_TYPES)];
extern const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)];
extern const aom_tree_index av1_inter_mode_tree[TREE_SIZE(INTER_MODES)];
extern const aom_tree_index av1_partition_tree[TREE_SIZE(PARTITION_TYPES)];
extern const aom_tree_index
vp10_switchable_interp_tree[TREE_SIZE(SWITCHABLE_FILTERS)];
av1_switchable_interp_tree[TREE_SIZE(SWITCHABLE_FILTERS)];
void vp10_setup_past_independence(struct VP10Common *cm);
void av1_setup_past_independence(struct AV1Common *cm);
void vp10_adapt_intra_frame_probs(struct VP10Common *cm);
void vp10_adapt_inter_frame_probs(struct VP10Common *cm);
void av1_adapt_intra_frame_probs(struct AV1Common *cm);
void av1_adapt_inter_frame_probs(struct AV1Common *cm);
void vp10_tx_counts_to_branch_counts_32x32(const unsigned int *tx_count_32x32p,
void av1_tx_counts_to_branch_counts_32x32(const unsigned int *tx_count_32x32p,
unsigned int (*ct_32x32p)[2]);
void vp10_tx_counts_to_branch_counts_16x16(const unsigned int *tx_count_16x16p,
void av1_tx_counts_to_branch_counts_16x16(const unsigned int *tx_count_16x16p,
unsigned int (*ct_16x16p)[2]);
void vp10_tx_counts_to_branch_counts_8x8(const unsigned int *tx_count_8x8p,
void av1_tx_counts_to_branch_counts_8x8(const unsigned int *tx_count_8x8p,
unsigned int (*ct_8x8p)[2]);
extern const aom_tree_index vp10_ext_tx_tree[TREE_SIZE(TX_TYPES)];
extern const aom_tree_index av1_ext_tx_tree[TREE_SIZE(TX_TYPES)];
static INLINE int vp10_ceil_log2(int n) {
static INLINE int av1_ceil_log2(int n) {
int i = 1, p = 2;
while (p < n) {
i++;
@ -139,4 +139,4 @@ static INLINE int vp10_ceil_log2(int n) {
} // extern "C"
#endif
#endif // VP10_COMMON_ENTROPYMODE_H_
#endif // AV1_COMMON_ENTROPYMODE_H_

32
av1/common/entropymv.c
Просмотреть файл

@ -15,12 +15,12 @@
// Integer pel reference mv threshold for use of high-precision 1/8 mv
#define COMPANDED_MVREF_THRESH 8
const aom_tree_index vp10_mv_joint_tree[TREE_SIZE(MV_JOINTS)] = {
const aom_tree_index av1_mv_joint_tree[TREE_SIZE(MV_JOINTS)] = {
-MV_JOINT_ZERO, 2, -MV_JOINT_HNZVZ, 4, -MV_JOINT_HZVNZ, -MV_JOINT_HNZVNZ
};
/* clang-format off */
const aom_tree_index vp10_mv_class_tree[TREE_SIZE(MV_CLASSES)] = {
const aom_tree_index av1_mv_class_tree[TREE_SIZE(MV_CLASSES)] = {
-MV_CLASS_0, 2,
-MV_CLASS_1, 4,
6, 8,
@ -34,11 +34,11 @@ const aom_tree_index vp10_mv_class_tree[TREE_SIZE(MV_CLASSES)] = {
};
/* clang-format on */
const aom_tree_index vp10_mv_class0_tree[TREE_SIZE(CLASS0_SIZE)] = {
const aom_tree_index av1_mv_class0_tree[TREE_SIZE(CLASS0_SIZE)] = {
-0, -1,
};
const aom_tree_index vp10_mv_fp_tree[TREE_SIZE(MV_FP_SIZE)] = { -0, 2, -1,
const aom_tree_index av1_mv_fp_tree[TREE_SIZE(MV_FP_SIZE)] = { -0, 2, -1,
4, -2, -3 };
static const nmv_context default_nmv_context = {
@ -114,7 +114,7 @@ static INLINE int mv_class_base(MV_CLASS_TYPE c) {
return c ? CLASS0_SIZE << (c + 2) : 0;
}
MV_CLASS_TYPE vp10_get_mv_class(int z, int *offset) {
MV_CLASS_TYPE av1_get_mv_class(int z, int *offset) {
const MV_CLASS_TYPE c = (z >= CLASS0_SIZE * 4096)
? MV_CLASS_10
: (MV_CLASS_TYPE)log_in_base_2[z >> 3];
@ -122,7 +122,7 @@ MV_CLASS_TYPE vp10_get_mv_class(int z, int *offset) {
return c;
}
int vp10_use_mv_hp(const MV *ref) {
int av1_use_mv_hp(const MV *ref) {
#if CONFIG_MISC_FIXES
(void)ref;
return 1;
@ -140,7 +140,7 @@ static void inc_mv_component(int v, nmv_component_counts *comp_counts, int incr,
comp_counts->sign[s] += incr;
z = (s ? -v : v) - 1; /* magnitude - 1 */
c = vp10_get_mv_class(z, &o);
c = av1_get_mv_class(z, &o);
comp_counts->classes[c] += incr;
d = (o >> 3); /* int mv data */
@ -160,9 +160,9 @@ static void inc_mv_component(int v, nmv_component_counts *comp_counts, int incr,
}
}
void vp10_inc_mv(const MV *mv, nmv_context_counts *counts, const int usehp) {
void av1_inc_mv(const MV *mv, nmv_context_counts *counts, const int usehp) {
if (counts != NULL) {
const MV_JOINT_TYPE j = vp10_get_mv_joint(mv);
const MV_JOINT_TYPE j = av1_get_mv_joint(mv);
++counts->joints[j];
if (mv_joint_vertical(j)) {
@ -177,14 +177,14 @@ void vp10_inc_mv(const MV *mv, nmv_context_counts *counts, const int usehp) {
}
}
void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
void av1_adapt_mv_probs(AV1_COMMON *cm, int allow_hp) {
int i, j;
nmv_context *fc = &cm->fc->nmvc;
const nmv_context *pre_fc = &cm->frame_contexts[cm->frame_context_idx].nmvc;
const nmv_context_counts *counts = &cm->counts.mv;
aom_tree_merge_probs(vp10_mv_joint_tree, pre_fc->joints, counts->joints,
aom_tree_merge_probs(av1_mv_joint_tree, pre_fc->joints, counts->joints,
fc->joints);
for (i = 0; i < 2; ++i) {
@ -193,19 +193,19 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
const nmv_component_counts *c = &counts->comps[i];
comp->sign = mode_mv_merge_probs(pre_comp->sign, c->sign);
aom_tree_merge_probs(vp10_mv_class_tree, pre_comp->classes, c->classes,
aom_tree_merge_probs(av1_mv_class_tree, pre_comp->classes, c->classes,
comp->classes);
aom_tree_merge_probs(vp10_mv_class0_tree, pre_comp->class0, c->class0,
aom_tree_merge_probs(av1_mv_class0_tree, pre_comp->class0, c->class0,
comp->class0);
for (j = 0; j < MV_OFFSET_BITS; ++j)
comp->bits[j] = mode_mv_merge_probs(pre_comp->bits[j], c->bits[j]);
for (j = 0; j < CLASS0_SIZE; ++j)
aom_tree_merge_probs(vp10_mv_fp_tree, pre_comp->class0_fp[j],
aom_tree_merge_probs(av1_mv_fp_tree, pre_comp->class0_fp[j],
c->class0_fp[j], comp->class0_fp[j]);
aom_tree_merge_probs(vp10_mv_fp_tree, pre_comp->fp, c->fp, comp->fp);
aom_tree_merge_probs(av1_mv_fp_tree, pre_comp->fp, c->fp, comp->fp);
if (allow_hp) {
comp->class0_hp = mode_mv_merge_probs(pre_comp->class0_hp, c->class0_hp);
@ -214,4 +214,4 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
}
}
void vp10_init_mv_probs(VP10_COMMON *cm) { cm->fc->nmvc = default_nmv_context; }
void av1_init_mv_probs(AV1_COMMON *cm) { cm->fc->nmvc = default_nmv_context; }

28
av1/common/entropymv.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ENTROPYMV_H_
#define VP10_COMMON_ENTROPYMV_H_
#ifndef AV1_COMMON_ENTROPYMV_H_
#define AV1_COMMON_ENTROPYMV_H_
#include "./aom_config.h"
@ -22,12 +22,12 @@
extern "C" {
#endif
struct VP10Common;
struct AV1Common;
void vp10_init_mv_probs(struct VP10Common *cm);
void av1_init_mv_probs(struct AV1Common *cm);
void vp10_adapt_mv_probs(struct VP10Common *cm, int usehp);
int vp10_use_mv_hp(const MV *ref);
void av1_adapt_mv_probs(struct AV1Common *cm, int usehp);
int av1_use_mv_hp(const MV *ref);
#define MV_UPDATE_PROB 252
@ -77,10 +77,10 @@ typedef enum {
#define MV_UPP ((1 << MV_IN_USE_BITS) - 1)
#define MV_LOW (-(1 << MV_IN_USE_BITS))
extern const aom_tree_index vp10_mv_joint_tree[];
extern const aom_tree_index vp10_mv_class_tree[];
extern const aom_tree_index vp10_mv_class0_tree[];
extern const aom_tree_index vp10_mv_fp_tree[];
extern const aom_tree_index av1_mv_joint_tree[];
extern const aom_tree_index av1_mv_class_tree[];
extern const aom_tree_index av1_mv_class0_tree[];
extern const aom_tree_index av1_mv_fp_tree[];
typedef struct {
aom_prob sign;
@ -98,7 +98,7 @@ typedef struct {
nmv_component comps[2];
} nmv_context;
static INLINE MV_JOINT_TYPE vp10_get_mv_joint(const MV *mv) {
static INLINE MV_JOINT_TYPE av1_get_mv_joint(const MV *mv) {
if (mv->row == 0) {
return mv->col == 0 ? MV_JOINT_ZERO : MV_JOINT_HNZVZ;
} else {
@ -106,7 +106,7 @@ static INLINE MV_JOINT_TYPE vp10_get_mv_joint(const MV *mv) {
}
}
MV_CLASS_TYPE vp10_get_mv_class(int z, int *offset);
MV_CLASS_TYPE av1_get_mv_class(int z, int *offset);
typedef struct {
unsigned int sign[2];
@ -124,10 +124,10 @@ typedef struct {
nmv_component_counts comps[2];
} nmv_context_counts;
void vp10_inc_mv(const MV *mv, nmv_context_counts *mvctx, const int usehp);
void av1_inc_mv(const MV *mv, nmv_context_counts *mvctx, const int usehp);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_ENTROPYMV_H_
#endif // AV1_COMMON_ENTROPYMV_H_

6
av1/common/enums.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ENUMS_H_
#define VP10_COMMON_ENUMS_H_
#ifndef AV1_COMMON_ENUMS_H_
#define AV1_COMMON_ENUMS_H_
#include "./aom_config.h"
#include "aom/aom_integer.h"
@ -143,4 +143,4 @@ typedef uint8_t PREDICTION_MODE;
} // extern "C"
#endif
#endif // VP10_COMMON_ENUMS_H_
#endif // AV1_COMMON_ENUMS_H_

2
av1/common/filter.c
Просмотреть файл

@ -64,6 +64,6 @@ DECLARE_ALIGNED(256, static const InterpKernel,
{ 0, -3, 2, 41, 63, 29, -2, -2 }, { 0, -3, 1, 38, 64, 32, -1, -3 }
};
const InterpKernel *vp10_filter_kernels[4] = {
const InterpKernel *av1_filter_kernels[4] = {
sub_pel_filters_8, sub_pel_filters_8lp, sub_pel_filters_8s, bilinear_filters
};

8
av1/common/filter.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_FILTER_H_
#define VP10_COMMON_FILTER_H_
#ifndef AV1_COMMON_FILTER_H_
#define AV1_COMMON_FILTER_H_
#include "./aom_config.h"
#include "aom/aom_integer.h"
@ -33,10 +33,10 @@ extern "C" {
typedef uint8_t INTERP_FILTER;
extern const InterpKernel *vp10_filter_kernels[4];
extern const InterpKernel *av1_filter_kernels[4];
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_FILTER_H_
#endif // AV1_COMMON_FILTER_H_

10
av1/common/frame_buffers.c
Просмотреть файл

@ -14,9 +14,9 @@
#include "av1/common/frame_buffers.h"
#include "aom_mem/aom_mem.h"
int vp10_alloc_internal_frame_buffers(InternalFrameBufferList *list) {
int av1_alloc_internal_frame_buffers(InternalFrameBufferList *list) {
assert(list != NULL);
vp10_free_internal_frame_buffers(list);
av1_free_internal_frame_buffers(list);
list->num_internal_frame_buffers =
VPX_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
@ -25,7 +25,7 @@ int vp10_alloc_internal_frame_buffers(InternalFrameBufferList *list) {
return (list->int_fb == NULL);
}
void vp10_free_internal_frame_buffers(InternalFrameBufferList *list) {
void av1_free_internal_frame_buffers(InternalFrameBufferList *list) {
int i;
assert(list != NULL);
@ -38,7 +38,7 @@ void vp10_free_internal_frame_buffers(InternalFrameBufferList *list) {
list->int_fb = NULL;
}
int vp10_get_frame_buffer(void *cb_priv, size_t min_size,
int av1_get_frame_buffer(void *cb_priv, size_t min_size,
aom_codec_frame_buffer_t *fb) {
int i;
InternalFrameBufferList *const int_fb_list =
@ -73,7 +73,7 @@ int vp10_get_frame_buffer(void *cb_priv, size_t min_size,
return 0;
}
int vp10_release_frame_buffer(void *cb_priv, aom_codec_frame_buffer_t *fb) {
int av1_release_frame_buffer(void *cb_priv, aom_codec_frame_buffer_t *fb) {
InternalFrameBuffer *const int_fb = (InternalFrameBuffer *)fb->priv;
(void)cb_priv;
if (int_fb) int_fb->in_use = 0;

14
av1/common/frame_buffers.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_FRAME_BUFFERS_H_
#define VP10_COMMON_FRAME_BUFFERS_H_
#ifndef AV1_COMMON_FRAME_BUFFERS_H_
#define AV1_COMMON_FRAME_BUFFERS_H_
#include "aom/aom_frame_buffer.h"
#include "aom/aom_integer.h"
@ -31,24 +31,24 @@ typedef struct InternalFrameBufferList {
} InternalFrameBufferList;
// Initializes |list|. Returns 0 on success.
int vp10_alloc_internal_frame_buffers(InternalFrameBufferList *list);
int av1_alloc_internal_frame_buffers(InternalFrameBufferList *list);
// Free any data allocated to the frame buffers.
void vp10_free_internal_frame_buffers(InternalFrameBufferList *list);
void av1_free_internal_frame_buffers(InternalFrameBufferList *list);
// Callback used by libaom to request an external frame buffer. |cb_priv|
// Callback private data, which points to an InternalFrameBufferList.
// |min_size| is the minimum size in bytes needed to decode the next frame.
// |fb| pointer to the frame buffer.
int vp10_get_frame_buffer(void *cb_priv, size_t min_size,
int av1_get_frame_buffer(void *cb_priv, size_t min_size,
aom_codec_frame_buffer_t *fb);
// Callback used by libaom when there are no references to the frame buffer.
// |cb_priv| is not used. |fb| pointer to the frame buffer.
int vp10_release_frame_buffer(void *cb_priv, aom_codec_frame_buffer_t *fb);
int av1_release_frame_buffer(void *cb_priv, aom_codec_frame_buffer_t *fb);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_FRAME_BUFFERS_H_
#endif // AV1_COMMON_FRAME_BUFFERS_H_

88
av1/common/idct.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "aom_dsp/inv_txfm.h"
#include "aom_ports/mem.h"
void vp10_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride,
void av1_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride,
int tx_type) {
const transform_2d IHT_4[] = {
{ idct4_c, idct4_c }, // DCT_DCT = 0
@ -57,7 +57,7 @@ static const transform_2d IHT_8[] = {
{ iadst8_c, iadst8_c } // ADST_ADST = 3
};
void vp10_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride,
void av1_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride,
int tx_type) {
int i, j;
tran_low_t out[8 * 8];
@ -90,7 +90,7 @@ static const transform_2d IHT_16[] = {
{ iadst16_c, iadst16_c } // ADST_ADST = 3
};
void vp10_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride,
void av1_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride,
int tx_type) {
int i, j;
tran_low_t out[16 * 16];
@ -117,7 +117,7 @@ void vp10_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride,
}
// idct
void vp10_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob) {
if (eob > 1)
aom_idct4x4_16_add(input, dest, stride);
@ -125,7 +125,7 @@ void vp10_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_idct4x4_1_add(input, dest, stride);
}
void vp10_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob) {
if (eob > 1)
aom_iwht4x4_16_add(input, dest, stride);
@ -133,14 +133,14 @@ void vp10_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_iwht4x4_1_add(input, dest, stride);
}
void vp10_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob) {
// If dc is 1, then input[0] is the reconstructed value, do not need
// dequantization. Also, when dc is 1, dc is counted in eobs, namely eobs >=1.
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to decide what to do.
// TODO(yunqingwang): "eobs = 1" case is also handled in vp10_short_idct8x8_c.
// TODO(yunqingwang): "eobs = 1" case is also handled in av1_short_idct8x8_c.
// Combine that with code here.
if (eob == 1)
// DC only DCT coefficient
@ -151,7 +151,7 @@ void vp10_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_idct8x8_64_add(input, dest, stride);
}
void vp10_idct16x16_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_idct16x16_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob) {
/* The calculation can be simplified if there are not many non-zero dct
* coefficients. Use eobs to separate different cases. */
@ -163,7 +163,7 @@ void vp10_idct16x16_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_idct16x16_256_add(input, dest, stride);
}
void vp10_idct32x32_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_idct32x32_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob) {
if (eob == 1)
aom_idct32x32_1_add(input, dest, stride);
@ -174,48 +174,48 @@ void vp10_idct32x32_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_idct32x32_1024_add(input, dest, stride);
}
void vp10_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type, int lossless) {
if (lossless) {
assert(tx_type == DCT_DCT);
vp10_iwht4x4_add(input, dest, stride, eob);
av1_iwht4x4_add(input, dest, stride, eob);
} else {
switch (tx_type) {
case DCT_DCT: vp10_idct4x4_add(input, dest, stride, eob); break;
case DCT_DCT: av1_idct4x4_add(input, dest, stride, eob); break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST: vp10_iht4x4_16_add(input, dest, stride, tx_type); break;
case ADST_ADST: av1_iht4x4_16_add(input, dest, stride, tx_type); break;
default: assert(0); break;
}
}
}
void vp10_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT: vp10_idct8x8_add(input, dest, stride, eob); break;
case DCT_DCT: av1_idct8x8_add(input, dest, stride, eob); break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST: vp10_iht8x8_64_add(input, dest, stride, tx_type); break;
case ADST_ADST: av1_iht8x8_64_add(input, dest, stride, tx_type); break;
default: assert(0); break;
}
}
void vp10_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT: vp10_idct16x16_add(input, dest, stride, eob); break;
case DCT_DCT: av1_idct16x16_add(input, dest, stride, eob); break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST: vp10_iht16x16_256_add(input, dest, stride, tx_type); break;
case ADST_ADST: av1_iht16x16_256_add(input, dest, stride, tx_type); break;
default: assert(0); break;
}
}
void vp10_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT: vp10_idct32x32_add(input, dest, stride, eob); break;
case DCT_DCT: av1_idct32x32_add(input, dest, stride, eob); break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST: assert(0); break;
@ -223,8 +223,8 @@ void vp10_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest, int stride,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
const highbd_transform_2d IHT_4[] = {
{ aom_highbd_idct4_c, aom_highbd_idct4_c }, // DCT_DCT = 0
@ -264,7 +264,7 @@ static const highbd_transform_2d HIGH_IHT_8[] = {
{ aom_highbd_iadst8_c, aom_highbd_iadst8_c } // ADST_ADST = 3
};
void vp10_highbd_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
int i, j;
tran_low_t out[8 * 8];
@ -298,7 +298,7 @@ static const highbd_transform_2d HIGH_IHT_16[] = {
{ aom_highbd_iadst16_c, aom_highbd_iadst16_c } // ADST_ADST = 3
};
void vp10_highbd_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
void av1_highbd_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
int i, j;
tran_low_t out[16 * 16];
@ -326,7 +326,7 @@ void vp10_highbd_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
}
// idct
void vp10_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
if (eob > 1)
aom_highbd_idct4x4_16_add(input, dest, stride, bd);
@ -334,7 +334,7 @@ void vp10_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_highbd_idct4x4_1_add(input, dest, stride, bd);
}
void vp10_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
if (eob > 1)
aom_highbd_iwht4x4_16_add(input, dest, stride, bd);
@ -342,14 +342,14 @@ void vp10_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
aom_highbd_iwht4x4_1_add(input, dest, stride, bd);
}
void vp10_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
// If dc is 1, then input[0] is the reconstructed value, do not need
// dequantization. Also, when dc is 1, dc is counted in eobs, namely eobs >=1.
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to decide what to do.
// TODO(yunqingwang): "eobs = 1" case is also handled in vp10_short_idct8x8_c.
// TODO(yunqingwang): "eobs = 1" case is also handled in av1_short_idct8x8_c.
// Combine that with code here.
// DC only DCT coefficient
if (eob == 1) {
@ -361,7 +361,7 @@ void vp10_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
}
}
void vp10_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
void av1_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd) {
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to separate different cases.
@ -375,7 +375,7 @@ void vp10_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
void av1_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd) {
// Non-zero coeff only in upper-left 8x8
if (eob == 1) {
@ -387,63 +387,63 @@ void vp10_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
}
}
void vp10_highbd_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd, TX_TYPE tx_type,
int lossless) {
if (lossless) {
assert(tx_type == DCT_DCT);
vp10_highbd_iwht4x4_add(input, dest, stride, eob, bd);
av1_highbd_iwht4x4_add(input, dest, stride, eob, bd);
} else {
switch (tx_type) {
case DCT_DCT:
vp10_highbd_idct4x4_add(input, dest, stride, eob, bd);
av1_highbd_idct4x4_add(input, dest, stride, eob, bd);
break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST:
vp10_highbd_iht4x4_16_add(input, dest, stride, tx_type, bd);
av1_highbd_iht4x4_16_add(input, dest, stride, tx_type, bd);
break;
default: assert(0); break;
}
}
}
void vp10_highbd_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd,
TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT: vp10_highbd_idct8x8_add(input, dest, stride, eob, bd); break;
case DCT_DCT: av1_highbd_idct8x8_add(input, dest, stride, eob, bd); break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST:
vp10_highbd_iht8x8_64_add(input, dest, stride, tx_type, bd);
av1_highbd_iht8x8_64_add(input, dest, stride, tx_type, bd);
break;
default: assert(0); break;
}
}
void vp10_highbd_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd,
TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT:
vp10_highbd_idct16x16_add(input, dest, stride, eob, bd);
av1_highbd_idct16x16_add(input, dest, stride, eob, bd);
break;
case ADST_DCT:
case DCT_ADST:
case ADST_ADST:
vp10_highbd_iht16x16_256_add(input, dest, stride, tx_type, bd);
av1_highbd_iht16x16_256_add(input, dest, stride, tx_type, bd);
break;
default: assert(0); break;
}
}
void vp10_highbd_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd,
TX_TYPE tx_type) {
switch (tx_type) {
case DCT_DCT:
vp10_highbd_idct32x32_add(input, dest, stride, eob, bd);
av1_highbd_idct32x32_add(input, dest, stride, eob, bd);
break;
case ADST_DCT:
case DCT_ADST:
@ -451,4 +451,4 @@ void vp10_highbd_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest,
default: assert(0); break;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH

44
av1/common/idct.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_IDCT_H_
#define VP10_COMMON_IDCT_H_
#ifndef AV1_COMMON_IDCT_H_
#define AV1_COMMON_IDCT_H_
#include <assert.h>
@ -31,53 +31,53 @@ typedef struct {
transform_1d cols, rows; // vertical and horizontal
} transform_2d;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
typedef void (*highbd_transform_1d)(const tran_low_t *, tran_low_t *, int bd);
typedef struct {
highbd_transform_1d cols, rows; // vertical and horizontal
} highbd_transform_2d;
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
void vp10_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob);
void vp10_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob);
void vp10_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type, int lossless);
void vp10_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type);
void vp10_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type);
void vp10_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest, int stride,
void av1_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest, int stride,
int eob, TX_TYPE tx_type);
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp10_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp10_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
void av1_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp10_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
void av1_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd);
void vp10_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
void av1_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd);
void vp10_highbd_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd, TX_TYPE tx_type,
int lossless);
void vp10_highbd_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_8x8(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd, TX_TYPE tx_type);
void vp10_highbd_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_16x16(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd,
TX_TYPE tx_type);
void vp10_highbd_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest,
void av1_highbd_inv_txfm_add_32x32(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd,
TX_TYPE tx_type);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_IDCT_H_
#endif // AV1_COMMON_IDCT_H_

78
av1/common/loopfilter.c
Просмотреть файл

@ -237,7 +237,7 @@ static uint8_t get_filter_level(const loop_filter_info_n *lfi_n,
->lvl[mbmi->segment_id][mbmi->ref_frame[0]][mode_lf_lut[mbmi->mode]];
}
void vp10_loop_filter_init(VP10_COMMON *cm) {
void av1_loop_filter_init(AV1_COMMON *cm) {
loop_filter_info_n *lfi = &cm->lf_info;
struct loopfilter *lf = &cm->lf;
int lvl;
@ -251,7 +251,7 @@ void vp10_loop_filter_init(VP10_COMMON *cm) {
memset(lfi->lfthr[lvl].hev_thr, (lvl >> 4), SIMD_WIDTH);
}
void vp10_loop_filter_frame_init(VP10_COMMON *cm, int default_filt_lvl) {
void av1_loop_filter_frame_init(AV1_COMMON *cm, int default_filt_lvl) {
int seg_id;
// n_shift is the multiplier for lf_deltas
// the multiplier is 1 for when filter_lvl is between 0 and 31;
@ -393,7 +393,7 @@ static void filter_selectively_vert_row2(int subsampling_factor, uint8_t *s,
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void highbd_filter_selectively_vert_row2(
int subsampling_factor, uint16_t *s, int pitch, unsigned int mask_16x16_l,
unsigned int mask_8x8_l, unsigned int mask_4x4_l,
@ -489,7 +489,7 @@ static void highbd_filter_selectively_vert_row2(
mask_4x4_int_1 >>= 1;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
static void filter_selectively_horiz(
uint8_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8,
@ -584,7 +584,7 @@ static void filter_selectively_horiz(
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void highbd_filter_selectively_horiz(
uint16_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8,
unsigned int mask_4x4, unsigned int mask_4x4_int,
@ -683,7 +683,7 @@ static void highbd_filter_selectively_horiz(
mask_4x4_int >>= count;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
// This function ors into the current lfm structure, where to do loop
// filters for the specific mi we are looking at. It uses information
@ -825,7 +825,7 @@ static void build_y_mask(const loop_filter_info_n *const lfi_n,
// This function sets up the bit masks for the entire 64x64 region represented
// by mi_row, mi_col.
// TODO(JBB): This function only works for yv12.
void vp10_setup_mask(VP10_COMMON *const cm, const int mi_row, const int mi_col,
void av1_setup_mask(AV1_COMMON *const cm, const int mi_row, const int mi_col,
MODE_INFO **mi, const int mode_info_stride,
LOOP_FILTER_MASK *lfm) {
int idx_32, idx_16, idx_8;
@ -860,7 +860,7 @@ void vp10_setup_mask(VP10_COMMON *const cm, const int mi_row, const int mi_col,
(mi_col + MI_BLOCK_SIZE > cm->mi_cols ? cm->mi_cols - mi_col
: MI_BLOCK_SIZE);
vp10_zero(*lfm);
av1_zero(*lfm);
assert(mip[0] != NULL);
// TODO(jimbankoski): Try moving most of the following code into decode
@ -1115,7 +1115,7 @@ static void filter_selectively_vert(
}
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static void highbd_filter_selectively_vert(
uint16_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8,
unsigned int mask_4x4, unsigned int mask_4x4_int,
@ -1149,9 +1149,9 @@ static void highbd_filter_selectively_vert(
mask_4x4_int >>= 1;
}
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
void vp10_filter_block_plane_non420(VP10_COMMON *cm,
void av1_filter_block_plane_non420(AV1_COMMON *cm,
struct macroblockd_plane *plane,
MODE_INFO **mi_8x8, int mi_row,
int mi_col) {
@ -1253,7 +1253,7 @@ void vp10_filter_block_plane_non420(VP10_COMMON *cm,
// Disable filtering on the leftmost column
border_mask = ~(mi_col == 0);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_vert(
CONVERT_TO_SHORTPTR(dst->buf), dst->stride,
@ -1270,7 +1270,7 @@ void vp10_filter_block_plane_non420(VP10_COMMON *cm,
filter_selectively_vert(dst->buf, dst->stride, mask_16x16_c & border_mask,
mask_8x8_c & border_mask, mask_4x4_c & border_mask,
mask_4x4_int[r], &cm->lf_info, &lfl[r << 3]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 8 * dst->stride;
mi_8x8 += row_step_stride;
}
@ -1294,7 +1294,7 @@ void vp10_filter_block_plane_non420(VP10_COMMON *cm,
mask_8x8_r = mask_8x8[r];
mask_4x4_r = mask_4x4[r];
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride, mask_16x16_r, mask_8x8_r,
@ -1309,12 +1309,12 @@ void vp10_filter_block_plane_non420(VP10_COMMON *cm,
filter_selectively_horiz(dst->buf, dst->stride, mask_16x16_r, mask_8x8_r,
mask_4x4_r, mask_4x4_int_r, &cm->lf_info,
&lfl[r << 3]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 8 * dst->stride;
}
}
void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
void av1_filter_block_plane_ss00(AV1_COMMON *const cm,
struct macroblockd_plane *const plane,
int mi_row, LOOP_FILTER_MASK *lfm) {
struct buf_2d *const dst = &plane->dst;
@ -1335,7 +1335,7 @@ void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
unsigned int mask_4x4_int_l = mask_4x4_int & 0xffff;
// Disable filtering on the leftmost column.
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_vert_row2(
plane->subsampling_x, CONVERT_TO_SHORTPTR(dst->buf), dst->stride,
@ -1350,7 +1350,7 @@ void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
filter_selectively_vert_row2(
plane->subsampling_x, dst->buf, dst->stride, mask_16x16_l, mask_8x8_l,
mask_4x4_l, mask_4x4_int_l, &cm->lf_info, &lfm->lfl_y[r << 3]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 16 * dst->stride;
mask_16x16 >>= 16;
mask_8x8 >>= 16;
@ -1380,7 +1380,7 @@ void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
mask_4x4_r = mask_4x4 & 0xff;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_horiz(
CONVERT_TO_SHORTPTR(dst->buf), dst->stride, mask_16x16_r, mask_8x8_r,
@ -1395,7 +1395,7 @@ void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
filter_selectively_horiz(dst->buf, dst->stride, mask_16x16_r, mask_8x8_r,
mask_4x4_r, mask_4x4_int & 0xff, &cm->lf_info,
&lfm->lfl_y[r << 3]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 8 * dst->stride;
mask_16x16 >>= 8;
@ -1405,7 +1405,7 @@ void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
}
}
void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
void av1_filter_block_plane_ss11(AV1_COMMON *const cm,
struct macroblockd_plane *const plane,
int mi_row, LOOP_FILTER_MASK *lfm) {
struct buf_2d *const dst = &plane->dst;
@ -1439,7 +1439,7 @@ void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
unsigned int mask_4x4_int_l = mask_4x4_int & 0xff;
// Disable filtering on the leftmost column.
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_vert_row2(
plane->subsampling_x, CONVERT_TO_SHORTPTR(dst->buf), dst->stride,
@ -1455,7 +1455,7 @@ void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
filter_selectively_vert_row2(
plane->subsampling_x, dst->buf, dst->stride, mask_16x16_l, mask_8x8_l,
mask_4x4_l, mask_4x4_int_l, &cm->lf_info, &lfm->lfl_uv[r << 1]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 16 * dst->stride;
mask_16x16 >>= 8;
@ -1494,7 +1494,7 @@ void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
mask_4x4_r = mask_4x4 & 0xf;
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (cm->use_highbitdepth) {
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride, mask_16x16_r, mask_8x8_r,
@ -1509,7 +1509,7 @@ void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
filter_selectively_horiz(dst->buf, dst->stride, mask_16x16_r, mask_8x8_r,
mask_4x4_r, mask_4x4_int_r, &cm->lf_info,
&lfm->lfl_uv[r << 1]);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
dst->buf += 8 * dst->stride;
mask_16x16 >>= 4;
@ -1519,7 +1519,7 @@ void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
}
}
void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, VP10_COMMON *cm,
void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int start, int stop, int y_only) {
const int num_planes = y_only ? 1 : MAX_MB_PLANE;
@ -1542,22 +1542,22 @@ void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, VP10_COMMON *cm,
for (mi_col = 0; mi_col < cm->mi_cols; mi_col += MI_BLOCK_SIZE) {
int plane;
vp10_setup_dst_planes(planes, frame_buffer, mi_row, mi_col);
av1_setup_dst_planes(planes, frame_buffer, mi_row, mi_col);
// TODO(JBB): Make setup_mask work for non 420.
vp10_setup_mask(cm, mi_row, mi_col, mi + mi_col, cm->mi_stride, &lfm);
av1_setup_mask(cm, mi_row, mi_col, mi + mi_col, cm->mi_stride, &lfm);
vp10_filter_block_plane_ss00(cm, &planes[0], mi_row, &lfm);
av1_filter_block_plane_ss00(cm, &planes[0], mi_row, &lfm);
for (plane = 1; plane < num_planes; ++plane) {
switch (path) {
case LF_PATH_420:
vp10_filter_block_plane_ss11(cm, &planes[plane], mi_row, &lfm);
av1_filter_block_plane_ss11(cm, &planes[plane], mi_row, &lfm);
break;
case LF_PATH_444:
vp10_filter_block_plane_ss00(cm, &planes[plane], mi_row, &lfm);
av1_filter_block_plane_ss00(cm, &planes[plane], mi_row, &lfm);
break;
case LF_PATH_SLOW:
vp10_filter_block_plane_non420(cm, &planes[plane], mi + mi_col,
av1_filter_block_plane_non420(cm, &planes[plane], mi + mi_col,
mi_row, mi_col);
break;
}
@ -1566,7 +1566,7 @@ void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, VP10_COMMON *cm,
}
}
void vp10_loop_filter_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
MACROBLOCKD *xd, int frame_filter_level, int y_only,
int partial_frame) {
int start_mi_row, end_mi_row, mi_rows_to_filter;
@ -1579,13 +1579,13 @@ void vp10_loop_filter_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm,
mi_rows_to_filter = VPXMAX(cm->mi_rows / 8, 8);
}
end_mi_row = start_mi_row + mi_rows_to_filter;
vp10_loop_filter_frame_init(cm, frame_filter_level);
vp10_loop_filter_rows(frame, cm, xd->plane, start_mi_row, end_mi_row, y_only);
av1_loop_filter_frame_init(cm, frame_filter_level);
av1_loop_filter_rows(frame, cm, xd->plane, start_mi_row, end_mi_row, y_only);
}
void vp10_loop_filter_data_reset(
void av1_loop_filter_data_reset(
LFWorkerData *lf_data, YV12_BUFFER_CONFIG *frame_buffer,
struct VP10Common *cm,
struct AV1Common *cm,
const struct macroblockd_plane planes[MAX_MB_PLANE]) {
lf_data->frame_buffer = frame_buffer;
lf_data->cm = cm;
@ -1595,9 +1595,9 @@ void vp10_loop_filter_data_reset(
memcpy(lf_data->planes, planes, sizeof(lf_data->planes));
}
int vp10_loop_filter_worker(LFWorkerData *const lf_data, void *unused) {
int av1_loop_filter_worker(LFWorkerData *const lf_data, void *unused) {
(void)unused;
vp10_loop_filter_rows(lf_data->frame_buffer, lf_data->cm, lf_data->planes,
av1_loop_filter_rows(lf_data->frame_buffer, lf_data->cm, lf_data->planes,
lf_data->start, lf_data->stop, lf_data->y_only);
return 1;
}

40
av1/common/loopfilter.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_LOOPFILTER_H_
#define VP10_COMMON_LOOPFILTER_H_
#ifndef AV1_COMMON_LOOPFILTER_H_
#define AV1_COMMON_LOOPFILTER_H_
#include "aom_ports/mem.h"
#include "./aom_config.h"
@ -92,49 +92,49 @@ typedef struct {
} LOOP_FILTER_MASK;
/* assorted loopfilter functions which get used elsewhere */
struct VP10Common;
struct AV1Common;
struct macroblockd;
struct VP10LfSyncData;
struct AV1LfSyncData;
// This function sets up the bit masks for the entire 64x64 region represented
// by mi_row, mi_col.
void vp10_setup_mask(struct VP10Common *const cm, const int mi_row,
void av1_setup_mask(struct AV1Common *const cm, const int mi_row,
const int mi_col, MODE_INFO **mi_8x8,
const int mode_info_stride, LOOP_FILTER_MASK *lfm);
void vp10_filter_block_plane_ss00(struct VP10Common *const cm,
void av1_filter_block_plane_ss00(struct AV1Common *const cm,
struct macroblockd_plane *const plane,
int mi_row, LOOP_FILTER_MASK *lfm);
void vp10_filter_block_plane_ss11(struct VP10Common *const cm,
void av1_filter_block_plane_ss11(struct AV1Common *const cm,
struct macroblockd_plane *const plane,
int mi_row, LOOP_FILTER_MASK *lfm);
void vp10_filter_block_plane_non420(struct VP10Common *cm,
void av1_filter_block_plane_non420(struct AV1Common *cm,
struct macroblockd_plane *plane,
MODE_INFO **mi_8x8, int mi_row, int mi_col);
void vp10_loop_filter_init(struct VP10Common *cm);
void av1_loop_filter_init(struct AV1Common *cm);
// Update the loop filter for the current frame.
// This should be called before vp10_loop_filter_rows(),
// vp10_loop_filter_frame()
// This should be called before av1_loop_filter_rows(),
// av1_loop_filter_frame()
// calls this function directly.
void vp10_loop_filter_frame_init(struct VP10Common *cm, int default_filt_lvl);
void av1_loop_filter_frame_init(struct AV1Common *cm, int default_filt_lvl);
void vp10_loop_filter_frame(YV12_BUFFER_CONFIG *frame, struct VP10Common *cm,
void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
struct macroblockd *mbd, int filter_level,
int y_only, int partial_frame);
// Apply the loop filter to [start, stop) macro block rows in frame_buffer.
void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer,
struct VP10Common *cm,
void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer,
struct AV1Common *cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int start, int stop, int y_only);
typedef struct LoopFilterWorkerData {
YV12_BUFFER_CONFIG *frame_buffer;
struct VP10Common *cm;
struct AV1Common *cm;
struct macroblockd_plane planes[MAX_MB_PLANE];
int start;
@ -142,14 +142,14 @@ typedef struct LoopFilterWorkerData {
int y_only;
} LFWorkerData;
void vp10_loop_filter_data_reset(
void av1_loop_filter_data_reset(
LFWorkerData *lf_data, YV12_BUFFER_CONFIG *frame_buffer,
struct VP10Common *cm, const struct macroblockd_plane planes[MAX_MB_PLANE]);
struct AV1Common *cm, const struct macroblockd_plane planes[MAX_MB_PLANE]);
// Operates on the rows described by 'lf_data'.
int vp10_loop_filter_worker(LFWorkerData *const lf_data, void *unused);
int av1_loop_filter_worker(LFWorkerData *const lf_data, void *unused);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // VP10_COMMON_LOOPFILTER_H_
#endif // AV1_COMMON_LOOPFILTER_H_

4
av1/common/mips/dspr2/itrans16_dspr2.c
Просмотреть файл

@ -22,7 +22,7 @@
#include "aom_ports/mem.h"
#if HAVE_DSPR2
void vp10_iht16x16_256_add_dspr2(const int16_t *input, uint8_t *dest, int pitch,
void av1_iht16x16_256_add_dspr2(const int16_t *input, uint8_t *dest, int pitch,
int tx_type) {
int i, j;
DECLARE_ALIGNED(32, int16_t, out[16 * 16]);
@ -91,7 +91,7 @@ void vp10_iht16x16_256_add_dspr2(const int16_t *input, uint8_t *dest, int pitch,
dest[j * pitch + i]);
}
} break;
default: printf("vp10_short_iht16x16_add_dspr2 : Invalid tx_type\n"); break;
default: printf("av1_short_iht16x16_add_dspr2 : Invalid tx_type\n"); break;
}
}
#endif // #if HAVE_DSPR2

4
av1/common/mips/dspr2/itrans4_dspr2.c
Просмотреть файл

@ -22,7 +22,7 @@
#include "aom_ports/mem.h"
#if HAVE_DSPR2
void vp10_iht4x4_16_add_dspr2(const int16_t *input, uint8_t *dest,
void av1_iht4x4_16_add_dspr2(const int16_t *input, uint8_t *dest,
int dest_stride, int tx_type) {
int i, j;
DECLARE_ALIGNED(32, int16_t, out[4 * 4]);
@ -85,7 +85,7 @@ void vp10_iht4x4_16_add_dspr2(const int16_t *input, uint8_t *dest,
ROUND_POWER_OF_TWO(temp_out[j], 4) + dest[j * dest_stride + i]);
}
break;
default: printf("vp10_short_iht4x4_add_dspr2 : Invalid tx_type\n"); break;
default: printf("av1_short_iht4x4_add_dspr2 : Invalid tx_type\n"); break;
}
}
#endif // #if HAVE_DSPR2

4
av1/common/mips/dspr2/itrans8_dspr2.c
Просмотреть файл

@ -21,7 +21,7 @@
#include "aom_ports/mem.h"
#if HAVE_DSPR2
void vp10_iht8x8_64_add_dspr2(const int16_t *input, uint8_t *dest,
void av1_iht8x8_64_add_dspr2(const int16_t *input, uint8_t *dest,
int dest_stride, int tx_type) {
int i, j;
DECLARE_ALIGNED(32, int16_t, out[8 * 8]);
@ -79,7 +79,7 @@ void vp10_iht8x8_64_add_dspr2(const int16_t *input, uint8_t *dest,
ROUND_POWER_OF_TWO(temp_out[j], 5) + dest[j * dest_stride + i]);
}
break;
default: printf("vp10_short_iht8x8_add_dspr2 : Invalid tx_type\n"); break;
default: printf("av1_short_iht8x8_add_dspr2 : Invalid tx_type\n"); break;
}
}
#endif // #if HAVE_DSPR2

2
av1/common/mips/msa/idct16x16_msa.c
Просмотреть файл

@ -14,7 +14,7 @@
#include "av1/common/enums.h"
#include "aom_dsp/mips/inv_txfm_msa.h"
void vp10_iht16x16_256_add_msa(const int16_t *input, uint8_t *dst,
void av1_iht16x16_256_add_msa(const int16_t *input, uint8_t *dst,
int32_t dst_stride, int32_t tx_type) {
int32_t i;
DECLARE_ALIGNED(32, int16_t, out[16 * 16]);

2
av1/common/mips/msa/idct4x4_msa.c
Просмотреть файл

@ -14,7 +14,7 @@
#include "av1/common/enums.h"
#include "aom_dsp/mips/inv_txfm_msa.h"
void vp10_iht4x4_16_add_msa(const int16_t *input, uint8_t *dst,
void av1_iht4x4_16_add_msa(const int16_t *input, uint8_t *dst,
int32_t dst_stride, int32_t tx_type) {
v8i16 in0, in1, in2, in3;

2
av1/common/mips/msa/idct8x8_msa.c
Просмотреть файл

@ -14,7 +14,7 @@
#include "av1/common/enums.h"
#include "aom_dsp/mips/inv_txfm_msa.h"
void vp10_iht8x8_64_add_msa(const int16_t *input, uint8_t *dst,
void av1_iht8x8_64_add_msa(const int16_t *input, uint8_t *dst,
int32_t dst_stride, int32_t tx_type) {
v8i16 in0, in1, in2, in3, in4, in5, in6, in7;

6
av1/common/mv.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_MV_H_
#define VP10_COMMON_MV_H_
#ifndef AV1_COMMON_MV_H_
#define AV1_COMMON_MV_H_
#include "aom/aom_integer.h"
@ -53,4 +53,4 @@ static INLINE void clamp_mv(MV *mv, int min_col, int max_col, int min_row,
} // extern "C"
#endif
#endif // VP10_COMMON_MV_H_
#endif // AV1_COMMON_MV_H_

10
av1/common/mvref_common.c
Просмотреть файл

@ -12,7 +12,7 @@
// This function searches the neighbourhood of a given MB/SB
// to try and find candidate reference vectors.
static void find_mv_refs_idx(const VP10_COMMON *cm, const MACROBLOCKD *xd,
static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list, int block, int mi_row,
int mi_col, find_mv_refs_sync sync,
@ -161,7 +161,7 @@ Done:
#endif
}
void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list, int mi_row, int mi_col,
find_mv_refs_sync sync, void *const data,
@ -171,14 +171,14 @@ void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
}
static void lower_mv_precision(MV *mv, int allow_hp) {
const int use_hp = allow_hp && vp10_use_mv_hp(mv);
const int use_hp = allow_hp && av1_use_mv_hp(mv);
if (!use_hp) {
if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1);
if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1);
}
}
void vp10_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
int_mv *near_mv) {
int i;
// Make sure all the candidates are properly clamped etc
@ -189,7 +189,7 @@ void vp10_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
*near_mv = mvlist[1];
}
void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd, int block,
void av1_append_sub8x8_mvs_for_idx(AV1_COMMON *cm, MACROBLOCKD *xd, int block,
int ref, int mi_row, int mi_col,
int_mv *nearest_mv, int_mv *near_mv,
uint8_t *mode_context) {

12
av1/common/mvref_common.h
Просмотреть файл

@ -8,8 +8,8 @@
* 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 VP10_COMMON_MVREF_COMMON_H_
#define VP10_COMMON_MVREF_COMMON_H_
#ifndef AV1_COMMON_MVREF_COMMON_H_
#define AV1_COMMON_MVREF_COMMON_H_
#include "av1/common/onyxc_int.h"
#include "av1/common/blockd.h"
@ -303,7 +303,7 @@ static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
}
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list, int mi_row, int mi_col,
find_mv_refs_sync sync, void *const data,
@ -312,10 +312,10 @@ void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
// check a list of motion vectors by sad score using a number rows of pixels
// above and a number cols of pixels in the left to select the one with best
// score to use as ref motion vector
void vp10_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
int_mv *near_mv);
void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd, int block,
void av1_append_sub8x8_mvs_for_idx(AV1_COMMON *cm, MACROBLOCKD *xd, int block,
int ref, int mi_row, int mi_col,
int_mv *nearest_mv, int_mv *near_mv,
uint8_t *mode_context);
@ -324,4 +324,4 @@ void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd, int block,
} // extern "C"
#endif
#endif // VP10_COMMON_MVREF_COMMON_H_
#endif // AV1_COMMON_MVREF_COMMON_H_

4
av1/common/odintrin.h
Просмотреть файл

@ -8,8 +8,8 @@
* 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 VP10_COMMON_ODINTRIN_H_
#define VP10_COMMON_ODINTRIN_H_
#ifndef AV1_COMMON_ODINTRIN_H_
#define AV1_COMMON_ODINTRIN_H_
#include "av1/common/enums.h"
#include "aom/aom_integer.h"

34
av1/common/onyxc_int.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_ONYXC_INT_H_
#define VP10_COMMON_ONYXC_INT_H_
#ifndef AV1_COMMON_ONYXC_INT_H_
#define AV1_COMMON_ONYXC_INT_H_
#include "./aom_config.h"
#include "aom/internal/aom_codec_internal.h"
@ -122,7 +122,7 @@ typedef struct BufferPool {
InternalFrameBufferList int_frame_buffers;
} BufferPool;
typedef struct VP10Common {
typedef struct AV1Common {
struct aom_internal_error_info error;
aom_color_space_t color_space;
int color_range;
@ -139,7 +139,7 @@ typedef struct VP10Common {
int subsampling_x;
int subsampling_y;
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
int use_highbitdepth; // Marks if we need to use 16bit frame buffers.
#endif
@ -229,9 +229,9 @@ typedef struct VP10Common {
MODE_INFO *prev_mi; /* 'mi' from last frame (points into prev_mip) */
// Separate mi functions between encoder and decoder.
int (*alloc_mi)(struct VP10Common *cm, int mi_size);
void (*free_mi)(struct VP10Common *cm);
void (*setup_mi)(struct VP10Common *cm);
int (*alloc_mi)(struct AV1Common *cm, int mi_size);
void (*free_mi)(struct AV1Common *cm);
void (*setup_mi)(struct AV1Common *cm);
// Grid of pointers to 8x8 MODE_INFO structs. Any 8x8 not in the visible
// area will be NULL.
@ -316,7 +316,7 @@ typedef struct VP10Common {
#if CONFIG_DERING
int dering_level;
#endif
} VP10_COMMON;
} AV1_COMMON;
// TODO(hkuang): Don't need to lock the whole pool after implementing atomic
// frame reference count.
@ -336,18 +336,18 @@ static void unlock_buffer_pool(BufferPool *const pool) {
#endif
}
static INLINE YV12_BUFFER_CONFIG *get_ref_frame(VP10_COMMON *cm, int index) {
static INLINE YV12_BUFFER_CONFIG *get_ref_frame(AV1_COMMON *cm, int index) {
if (index < 0 || index >= REF_FRAMES) return NULL;
if (cm->ref_frame_map[index] < 0) return NULL;
assert(cm->ref_frame_map[index] < FRAME_BUFFERS);
return &cm->buffer_pool->frame_bufs[cm->ref_frame_map[index]].buf;
}
static INLINE YV12_BUFFER_CONFIG *get_frame_new_buffer(VP10_COMMON *cm) {
static INLINE YV12_BUFFER_CONFIG *get_frame_new_buffer(AV1_COMMON *cm) {
return &cm->buffer_pool->frame_bufs[cm->new_fb_idx].buf;
}
static INLINE int get_free_fb(VP10_COMMON *cm) {
static INLINE int get_free_fb(AV1_COMMON *cm) {
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
int i;
@ -381,11 +381,11 @@ static INLINE int mi_cols_aligned_to_sb(int n_mis) {
return ALIGN_POWER_OF_TWO(n_mis, MI_BLOCK_SIZE_LOG2);
}
static INLINE int frame_is_intra_only(const VP10_COMMON *const cm) {
static INLINE int frame_is_intra_only(const AV1_COMMON *const cm) {
return cm->frame_type == KEY_FRAME || cm->intra_only;
}
static INLINE void vp10_init_macroblockd(VP10_COMMON *cm, MACROBLOCKD *xd,
static INLINE void av1_init_macroblockd(AV1_COMMON *cm, MACROBLOCKD *xd,
tran_low_t *dqcoeff) {
int i;
@ -461,13 +461,13 @@ static INLINE void set_mi_row_col(MACROBLOCKD *xd, const TileInfo *const tile,
}
}
static INLINE const aom_prob *get_y_mode_probs(const VP10_COMMON *cm,
static INLINE const aom_prob *get_y_mode_probs(const AV1_COMMON *cm,
const MODE_INFO *mi,
const MODE_INFO *above_mi,
const MODE_INFO *left_mi,
int block) {
const PREDICTION_MODE above = vp10_above_block_mode(mi, above_mi, block);
const PREDICTION_MODE left = vp10_left_block_mode(mi, left_mi, block);
const PREDICTION_MODE above = av1_above_block_mode(mi, above_mi, block);
const PREDICTION_MODE left = av1_left_block_mode(mi, left_mi, block);
return cm->kf_y_prob[above][left];
}
@ -504,4 +504,4 @@ static INLINE int partition_plane_context(const MACROBLOCKD *xd, int mi_row,
} // extern "C"
#endif
#endif // VP10_COMMON_ONYXC_INT_H_
#endif // AV1_COMMON_ONYXC_INT_H_

12
av1/common/pred_common.c
Просмотреть файл

@ -13,7 +13,7 @@
#include "av1/common/seg_common.h"
// Returns a context number for the given MB prediction signal
int vp10_get_pred_context_switchable_interp(const MACROBLOCKD *xd) {
int av1_get_pred_context_switchable_interp(const MACROBLOCKD *xd) {
// Note:
// The mode info data structure has a one element border above and to the
// left of the entries correpsonding to real macroblocks.
@ -44,7 +44,7 @@ int vp10_get_pred_context_switchable_interp(const MACROBLOCKD *xd) {
// 1 - intra/inter, inter/intra
// 2 - intra/--, --/intra
// 3 - intra/intra
int vp10_get_intra_inter_context(const MACROBLOCKD *xd) {
int av1_get_intra_inter_context(const MACROBLOCKD *xd) {
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
const int has_above = xd->up_available;
@ -61,7 +61,7 @@ int vp10_get_intra_inter_context(const MACROBLOCKD *xd) {
}
}
int vp10_get_reference_mode_context(const VP10_COMMON *cm,
int av1_get_reference_mode_context(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
int ctx;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
@ -104,7 +104,7 @@ int vp10_get_reference_mode_context(const VP10_COMMON *cm,
}
// Returns a context number for the given MB prediction signal
int vp10_get_pred_context_comp_ref_p(const VP10_COMMON *cm,
int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
@ -186,7 +186,7 @@ int vp10_get_pred_context_comp_ref_p(const VP10_COMMON *cm,
return pred_context;
}
int vp10_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
int av1_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@ -252,7 +252,7 @@ int vp10_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
return pred_context;
}
int vp10_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
int av1_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;

52
av1/common/pred_common.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_PRED_COMMON_H_
#define VP10_COMMON_PRED_COMMON_H_
#ifndef AV1_COMMON_PRED_COMMON_H_
#define AV1_COMMON_PRED_COMMON_H_
#include "av1/common/blockd.h"
#include "av1/common/onyxc_int.h"
@ -20,7 +20,7 @@
extern "C" {
#endif
static INLINE int get_segment_id(const VP10_COMMON *cm,
static INLINE int get_segment_id(const AV1_COMMON *cm,
const uint8_t *segment_ids, BLOCK_SIZE bsize,
int mi_row, int mi_col) {
const int mi_offset = mi_row * cm->mi_cols + mi_col;
@ -39,7 +39,7 @@ static INLINE int get_segment_id(const VP10_COMMON *cm,
return segment_id;
}
static INLINE int vp10_get_pred_context_seg_id(const MACROBLOCKD *xd) {
static INLINE int av1_get_pred_context_seg_id(const MACROBLOCKD *xd) {
const MODE_INFO *const above_mi = xd->above_mi;
const MODE_INFO *const left_mi = xd->left_mi;
const int above_sip =
@ -49,12 +49,12 @@ static INLINE int vp10_get_pred_context_seg_id(const MACROBLOCKD *xd) {
return above_sip + left_sip;
}
static INLINE aom_prob vp10_get_pred_prob_seg_id(
static INLINE aom_prob av1_get_pred_prob_seg_id(
const struct segmentation_probs *segp, const MACROBLOCKD *xd) {
return segp->pred_probs[vp10_get_pred_context_seg_id(xd)];
return segp->pred_probs[av1_get_pred_context_seg_id(xd)];
}
static INLINE int vp10_get_skip_context(const MACROBLOCKD *xd) {
static INLINE int av1_get_skip_context(const MACROBLOCKD *xd) {
const MODE_INFO *const above_mi = xd->above_mi;
const MODE_INFO *const left_mi = xd->left_mi;
const int above_skip = (above_mi != NULL) ? above_mi->mbmi.skip : 0;
@ -62,49 +62,49 @@ static INLINE int vp10_get_skip_context(const MACROBLOCKD *xd) {
return above_skip + left_skip;
}
static INLINE aom_prob vp10_get_skip_prob(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_skip_prob(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->skip_probs[vp10_get_skip_context(xd)];
return cm->fc->skip_probs[av1_get_skip_context(xd)];
}
int vp10_get_pred_context_switchable_interp(const MACROBLOCKD *xd);
int av1_get_pred_context_switchable_interp(const MACROBLOCKD *xd);
int vp10_get_intra_inter_context(const MACROBLOCKD *xd);
int av1_get_intra_inter_context(const MACROBLOCKD *xd);
static INLINE aom_prob vp10_get_intra_inter_prob(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_intra_inter_prob(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->intra_inter_prob[vp10_get_intra_inter_context(xd)];
return cm->fc->intra_inter_prob[av1_get_intra_inter_context(xd)];
}
int vp10_get_reference_mode_context(const VP10_COMMON *cm,
int av1_get_reference_mode_context(const AV1_COMMON *cm,
const MACROBLOCKD *xd);
static INLINE aom_prob vp10_get_reference_mode_prob(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_reference_mode_prob(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->comp_inter_prob[vp10_get_reference_mode_context(cm, xd)];
return cm->fc->comp_inter_prob[av1_get_reference_mode_context(cm, xd)];
}
int vp10_get_pred_context_comp_ref_p(const VP10_COMMON *cm,
int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd);
static INLINE aom_prob vp10_get_pred_prob_comp_ref_p(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_pred_prob_comp_ref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
const int pred_context = vp10_get_pred_context_comp_ref_p(cm, xd);
const int pred_context = av1_get_pred_context_comp_ref_p(cm, xd);
return cm->fc->comp_ref_prob[pred_context];
}
int vp10_get_pred_context_single_ref_p1(const MACROBLOCKD *xd);
int av1_get_pred_context_single_ref_p1(const MACROBLOCKD *xd);
static INLINE aom_prob vp10_get_pred_prob_single_ref_p1(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_pred_prob_single_ref_p1(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->single_ref_prob[vp10_get_pred_context_single_ref_p1(xd)][0];
return cm->fc->single_ref_prob[av1_get_pred_context_single_ref_p1(xd)][0];
}
int vp10_get_pred_context_single_ref_p2(const MACROBLOCKD *xd);
int av1_get_pred_context_single_ref_p2(const MACROBLOCKD *xd);
static INLINE aom_prob vp10_get_pred_prob_single_ref_p2(const VP10_COMMON *cm,
static INLINE aom_prob av1_get_pred_prob_single_ref_p2(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->single_ref_prob[vp10_get_pred_context_single_ref_p2(xd)][1];
return cm->fc->single_ref_prob[av1_get_pred_context_single_ref_p2(xd)][1];
}
// Returns a context number for the given MB prediction signal
@ -158,4 +158,4 @@ static INLINE unsigned int *get_tx_counts(TX_SIZE max_tx_size, int ctx,
} // extern "C"
#endif
#endif // VP10_COMMON_PRED_COMMON_H_
#endif // AV1_COMMON_PRED_COMMON_H_

20
av1/common/quant_common.c
Просмотреть файл

@ -41,7 +41,7 @@ static const int16_t dc_qlookup[QINDEX_RANGE] = {
1184, 1232, 1282, 1336,
};
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static const int16_t dc_qlookup_10[QINDEX_RANGE] = {
4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34, 37,
40, 43, 47, 50, 53, 57, 60, 64, 68, 71, 75, 78, 82,
@ -116,7 +116,7 @@ static const int16_t ac_qlookup[QINDEX_RANGE] = {
1567, 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828,
};
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static const int16_t ac_qlookup_10[QINDEX_RANGE] = {
4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37, 40,
44, 48, 51, 55, 59, 63, 67, 71, 75, 79, 83, 88, 92,
@ -168,8 +168,8 @@ static const int16_t ac_qlookup_12[QINDEX_RANGE] = {
};
#endif
int16_t vp10_dc_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#if CONFIG_VPX_HIGHBITDEPTH
int16_t av1_dc_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#if CONFIG_AOM_HIGHBITDEPTH
switch (bit_depth) {
case VPX_BITS_8: return dc_qlookup[clamp(qindex + delta, 0, MAXQ)];
case VPX_BITS_10: return dc_qlookup_10[clamp(qindex + delta, 0, MAXQ)];
@ -184,8 +184,8 @@ int16_t vp10_dc_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#endif
}
int16_t vp10_ac_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#if CONFIG_VPX_HIGHBITDEPTH
int16_t av1_ac_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#if CONFIG_AOM_HIGHBITDEPTH
switch (bit_depth) {
case VPX_BITS_8: return ac_qlookup[clamp(qindex + delta, 0, MAXQ)];
case VPX_BITS_10: return ac_qlookup_10[clamp(qindex + delta, 0, MAXQ)];
@ -200,7 +200,7 @@ int16_t vp10_ac_quant(int qindex, int delta, aom_bit_depth_t bit_depth) {
#endif
}
int vp10_get_qindex(const struct segmentation *seg, int segment_id,
int av1_get_qindex(const struct segmentation *seg, int segment_id,
int base_qindex) {
if (segfeature_active(seg, segment_id, SEG_LVL_ALT_Q)) {
const int data = get_segdata(seg, segment_id, SEG_LVL_ALT_Q);
@ -213,11 +213,11 @@ int vp10_get_qindex(const struct segmentation *seg, int segment_id,
}
#if CONFIG_AOM_QM
qm_val_t* aom_iqmatrix(VP10_COMMON* cm, int qmlevel, int is_chroma,
qm_val_t* aom_iqmatrix(AV1_COMMON* cm, int qmlevel, int is_chroma,
int log2sizem2, int is_intra) {
return &cm->giqmatrix[qmlevel][!!is_chroma][!!is_intra][log2sizem2][0];
}
qm_val_t* aom_qmatrix(VP10_COMMON* cm, int qmlevel, int is_chroma,
qm_val_t* aom_qmatrix(AV1_COMMON* cm, int qmlevel, int is_chroma,
int log2sizem2, int is_intra) {
return &cm->gqmatrix[qmlevel][!!is_chroma][!!is_intra][log2sizem2][0];
}
@ -227,7 +227,7 @@ static uint16_t
static uint16_t
wt_matrix_ref[NUM_QM_LEVELS][2][2][4 * 4 + 8 * 8 + 16 * 16 + 32 * 32];
void aom_qm_init(VP10_COMMON* cm) {
void aom_qm_init(AV1_COMMON* cm) {
int q, c, f, t, size;
int current;
for (q = 0; q < NUM_QM_LEVELS; ++q) {

20
av1/common/quant_common.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_QUANT_COMMON_H_
#define VP10_COMMON_QUANT_COMMON_H_
#ifndef AV1_COMMON_QUANT_COMMON_H_
#define AV1_COMMON_QUANT_COMMON_H_
#include "aom/aom_codec.h"
#include "av1/common/seg_common.h"
@ -35,12 +35,12 @@ extern "C" {
#define DEFAULT_QM_LAST (NUM_QM_LEVELS - 1)
#endif
struct VP10Common;
struct AV1Common;
int16_t vp10_dc_quant(int qindex, int delta, aom_bit_depth_t bit_depth);
int16_t vp10_ac_quant(int qindex, int delta, aom_bit_depth_t bit_depth);
int16_t av1_dc_quant(int qindex, int delta, aom_bit_depth_t bit_depth);
int16_t av1_ac_quant(int qindex, int delta, aom_bit_depth_t bit_depth);
int vp10_get_qindex(const struct segmentation *seg, int segment_id,
int av1_get_qindex(const struct segmentation *seg, int segment_id,
int base_qindex);
#if CONFIG_AOM_QM
// Reduce the large number of quantizers to a smaller number of levels for which
@ -50,10 +50,10 @@ static inline int aom_get_qmlevel(int qindex, int first, int last) {
qmlevel = VPXMIN(qmlevel + first, NUM_QM_LEVELS - 1);
return qmlevel;
}
void aom_qm_init(struct VP10Common *cm);
qm_val_t *aom_iqmatrix(struct VP10Common *cm, int qindex, int comp,
void aom_qm_init(struct AV1Common *cm);
qm_val_t *aom_iqmatrix(struct AV1Common *cm, int qindex, int comp,
int log2sizem2, int is_intra);
qm_val_t *aom_qmatrix(struct VP10Common *cm, int qindex, int comp,
qm_val_t *aom_qmatrix(struct AV1Common *cm, int qindex, int comp,
int log2sizem2, int is_intra);
#endif
@ -61,4 +61,4 @@ qm_val_t *aom_qmatrix(struct VP10Common *cm, int qindex, int comp,
} // extern "C"
#endif
#endif // VP10_COMMON_QUANT_COMMON_H_
#endif // AV1_COMMON_QUANT_COMMON_H_

48
av1/common/reconinter.c
Просмотреть файл

@ -20,8 +20,8 @@
#include "av1/common/reconinter.h"
#include "av1/common/reconintra.h"
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_build_inter_predictor(
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_build_inter_predictor(
const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride,
const MV *src_mv, const struct scale_factors *sf, int w, int h, int ref,
const InterpKernel *kernel, enum mv_precision precision, int x, int y,
@ -29,7 +29,7 @@ void vp10_highbd_build_inter_predictor(
const int is_q4 = precision == MV_PRECISION_Q4;
const MV mv_q4 = { is_q4 ? src_mv->row : src_mv->row * 2,
is_q4 ? src_mv->col : src_mv->col * 2 };
MV32 mv = vp10_scale_mv(&mv_q4, x, y, sf);
MV32 mv = av1_scale_mv(&mv_q4, x, y, sf);
const int subpel_x = mv.col & SUBPEL_MASK;
const int subpel_y = mv.row & SUBPEL_MASK;
@ -38,9 +38,9 @@ void vp10_highbd_build_inter_predictor(
high_inter_predictor(src, src_stride, dst, dst_stride, subpel_x, subpel_y, sf,
w, h, ref, kernel, sf->x_step_q4, sf->y_step_q4, bd);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
void vp10_build_inter_predictor(const uint8_t *src, int src_stride,
void av1_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride, const MV *src_mv,
const struct scale_factors *sf, int w, int h,
int ref, const InterpKernel *kernel,
@ -48,7 +48,7 @@ void vp10_build_inter_predictor(const uint8_t *src, int src_stride,
const int is_q4 = precision == MV_PRECISION_Q4;
const MV mv_q4 = { is_q4 ? src_mv->row : src_mv->row * 2,
is_q4 ? src_mv->col : src_mv->col * 2 };
MV32 mv = vp10_scale_mv(&mv_q4, x, y, sf);
MV32 mv = av1_scale_mv(&mv_q4, x, y, sf);
const int subpel_x = mv.col & SUBPEL_MASK;
const int subpel_y = mv.row & SUBPEL_MASK;
@ -64,7 +64,7 @@ void build_inter_predictors(MACROBLOCKD *xd, int plane, int block, int bw,
struct macroblockd_plane *const pd = &xd->plane[plane];
const MODE_INFO *mi = xd->mi[0];
const int is_compound = has_second_ref(&mi->mbmi);
const InterpKernel *kernel = vp10_filter_kernels[mi->mbmi.interp_filter];
const InterpKernel *kernel = av1_filter_kernels[mi->mbmi.interp_filter];
int ref;
for (ref = 0; ref < 1 + is_compound; ++ref) {
@ -87,11 +87,11 @@ void build_inter_predictors(MACROBLOCKD *xd, int plane, int block, int bw,
uint8_t *pre;
MV32 scaled_mv;
int xs, ys, subpel_x, subpel_y;
const int is_scaled = vp10_is_scaled(sf);
const int is_scaled = av1_is_scaled(sf);
if (is_scaled) {
pre = pre_buf->buf + scaled_buffer_offset(x, y, pre_buf->stride, sf);
scaled_mv = vp10_scale_mv(&mv_q4, mi_x + x, mi_y + y, sf);
scaled_mv = av1_scale_mv(&mv_q4, mi_x + x, mi_y + y, sf);
xs = sf->x_step_q4;
ys = sf->y_step_q4;
} else {
@ -105,7 +105,7 @@ void build_inter_predictors(MACROBLOCKD *xd, int plane, int block, int bw,
pre += (scaled_mv.row >> SUBPEL_BITS) * pre_buf->stride +
(scaled_mv.col >> SUBPEL_BITS);
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
high_inter_predictor(pre, pre_buf->stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, kernel, xs, ys, xd->bd);
@ -116,11 +116,11 @@ void build_inter_predictors(MACROBLOCKD *xd, int plane, int block, int bw,
#else
inter_predictor(pre, pre_buf->stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, kernel, xs, ys);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
void vp10_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane, int i,
void av1_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane, int i,
int ir, int ic, int mi_row, int mi_col) {
struct macroblockd_plane *const pd = &xd->plane[plane];
MODE_INFO *const mi = xd->mi[0];
@ -131,32 +131,32 @@ void vp10_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane, int i,
uint8_t *const dst = &pd->dst.buf[(ir * pd->dst.stride + ic) << 2];
int ref;
const int is_compound = has_second_ref(&mi->mbmi);
const InterpKernel *kernel = vp10_filter_kernels[mi->mbmi.interp_filter];
const InterpKernel *kernel = av1_filter_kernels[mi->mbmi.interp_filter];
for (ref = 0; ref < 1 + is_compound; ++ref) {
const uint8_t *pre =
&pd->pre[ref].buf[(ir * pd->pre[ref].stride + ic) << 2];
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp10_highbd_build_inter_predictor(
av1_highbd_build_inter_predictor(
pre, pd->pre[ref].stride, dst, pd->dst.stride,
&mi->bmi[i].as_mv[ref].as_mv, &xd->block_refs[ref]->sf, width, height,
ref, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE + 4 * ic,
mi_row * MI_SIZE + 4 * ir, xd->bd);
} else {
vp10_build_inter_predictor(
av1_build_inter_predictor(
pre, pd->pre[ref].stride, dst, pd->dst.stride,
&mi->bmi[i].as_mv[ref].as_mv, &xd->block_refs[ref]->sf, width, height,
ref, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE + 4 * ic,
mi_row * MI_SIZE + 4 * ir);
}
#else
vp10_build_inter_predictor(
av1_build_inter_predictor(
pre, pd->pre[ref].stride, dst, pd->dst.stride,
&mi->bmi[i].as_mv[ref].as_mv, &xd->block_refs[ref]->sf, width, height,
ref, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE + 4 * ic,
mi_row * MI_SIZE + 4 * ir);
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
@ -193,29 +193,29 @@ static void build_inter_predictors_for_planes(MACROBLOCKD *xd, BLOCK_SIZE bsize,
}
}
void vp10_build_inter_predictors_sby(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sby(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
build_inter_predictors_for_planes(xd, bsize, mi_row, mi_col, 0, 0);
}
void vp10_build_inter_predictors_sbp(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sbp(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize, int plane) {
build_inter_predictors_for_planes(xd, bsize, mi_row, mi_col, plane, plane);
}
void vp10_build_inter_predictors_sbuv(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sbuv(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
build_inter_predictors_for_planes(xd, bsize, mi_row, mi_col, 1,
MAX_MB_PLANE - 1);
}
void vp10_build_inter_predictors_sb(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sb(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
build_inter_predictors_for_planes(xd, bsize, mi_row, mi_col, 0,
MAX_MB_PLANE - 1);
}
void vp10_setup_dst_planes(struct macroblockd_plane planes[MAX_MB_PLANE],
void av1_setup_dst_planes(struct macroblockd_plane planes[MAX_MB_PLANE],
const YV12_BUFFER_CONFIG *src, int mi_row,
int mi_col) {
uint8_t *const buffers[MAX_MB_PLANE] = { src->y_buffer, src->u_buffer,
@ -231,7 +231,7 @@ void vp10_setup_dst_planes(struct macroblockd_plane planes[MAX_MB_PLANE],
}
}
void vp10_setup_pre_planes(MACROBLOCKD *xd, int idx,
void av1_setup_pre_planes(MACROBLOCKD *xd, int idx,
const YV12_BUFFER_CONFIG *src, int mi_row,
int mi_col, const struct scale_factors *sf) {
if (src != NULL) {

30
av1/common/reconinter.h
Просмотреть файл

@ -9,8 +9,8 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef VP10_COMMON_RECONINTER_H_
#define VP10_COMMON_RECONINTER_H_
#ifndef AV1_COMMON_RECONINTER_H_
#define AV1_COMMON_RECONINTER_H_
#include "av1/common/filter.h"
#include "av1/common/onyxc_int.h"
@ -32,7 +32,7 @@ static INLINE void inter_predictor(const uint8_t *src, int src_stride,
ys, w, h);
}
#if CONFIG_VPX_HIGHBITDEPTH
#if CONFIG_AOM_HIGHBITDEPTH
static INLINE void high_inter_predictor(
const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride,
const int subpel_x, const int subpel_y, const struct scale_factors *sf,
@ -41,7 +41,7 @@ static INLINE void high_inter_predictor(
src, src_stride, dst, dst_stride, kernel[subpel_x], xs, kernel[subpel_y],
ys, w, h, bd);
}
#endif // CONFIG_VPX_HIGHBITDEPTH
#endif // CONFIG_AOM_HIGHBITDEPTH
static INLINE int round_mv_comp_q4(int value) {
return (value < 0 ? value - 2 : value + 2) / 4;
@ -113,29 +113,29 @@ void build_inter_predictors(MACROBLOCKD *xd, int plane, int block, int bw,
int bh, int x, int y, int w, int h, int mi_x,
int mi_y);
void vp10_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane, int i,
void av1_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane, int i,
int ir, int ic, int mi_row, int mi_col);
void vp10_build_inter_predictors_sby(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sby(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize);
void vp10_build_inter_predictors_sbp(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sbp(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize, int plane);
void vp10_build_inter_predictors_sbuv(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sbuv(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize);
void vp10_build_inter_predictors_sb(MACROBLOCKD *xd, int mi_row, int mi_col,
void av1_build_inter_predictors_sb(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize);
void vp10_build_inter_predictor(const uint8_t *src, int src_stride,
void av1_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride, const MV *mv_q3,
const struct scale_factors *sf, int w, int h,
int do_avg, const InterpKernel *kernel,
enum mv_precision precision, int x, int y);
#if CONFIG_VPX_HIGHBITDEPTH
void vp10_highbd_build_inter_predictor(
#if CONFIG_AOM_HIGHBITDEPTH
void av1_highbd_build_inter_predictor(
const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride,
const MV *mv_q3, const struct scale_factors *sf, int w, int h, int do_avg,
const InterpKernel *kernel, enum mv_precision precision, int x, int y,
@ -159,11 +159,11 @@ static INLINE void setup_pred_plane(struct buf_2d *dst, uint8_t *src,
dst->stride = stride;
}
void vp10_setup_dst_planes(struct macroblockd_plane planes[MAX_MB_PLANE],
void av1_setup_dst_planes(struct macroblockd_plane planes[MAX_MB_PLANE],
const YV12_BUFFER_CONFIG *src, int mi_row,
int mi_col);
void vp10_setup_pre_planes(MACROBLOCKD *xd, int idx,
void av1_setup_pre_planes(MACROBLOCKD *xd, int idx,
const YV12_BUFFER_CONFIG *src, int mi_row,
int mi_col, const struct scale_factors *sf);
@ -171,4 +171,4 @@ void vp10_setup_pre_planes(MACROBLOCKD *xd, int idx,
} // extern "C"
#endif
#endif // VP10_COMMON_RECONINTER_H_
#endif // AV1_COMMON_RECONINTER_H_

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше