From 96baa73ed9ad135214efbaaa13d16a1c77d3049c Mon Sep 17 00:00:00 2001 From: Angie Chiang Date: Wed, 18 Nov 2015 15:17:18 -0800 Subject: [PATCH] Create hybrid_fwd_txfm.c Move txfm functions from encodemb to hybrid_twd_txfm.c to make encodemb's code flow clear Change-Id: If174d8ddb490d149c103e5127d30ef19adfbed13 --- vp10/encoder/encodemb.c | 450 ++++----------------------------- vp10/encoder/encodemb.h | 8 - vp10/encoder/hybrid_fwd_txfm.c | 406 +++++++++++++++++++++++++++++ vp10/encoder/hybrid_fwd_txfm.h | 62 +++++ vp10/encoder/rdopt.c | 1 + vp10/vp10cx.mk | 2 + 6 files changed, 522 insertions(+), 407 deletions(-) create mode 100644 vp10/encoder/hybrid_fwd_txfm.c create mode 100644 vp10/encoder/hybrid_fwd_txfm.h diff --git a/vp10/encoder/encodemb.c b/vp10/encoder/encodemb.c index 1565846bf..94a7eed98 100644 --- a/vp10/encoder/encodemb.c +++ b/vp10/encoder/encodemb.c @@ -23,14 +23,10 @@ #include "vp10/common/scan.h" #include "vp10/encoder/encodemb.h" +#include "vp10/encoder/hybrid_fwd_txfm.h" #include "vp10/encoder/rd.h" #include "vp10/encoder/tokenize.h" -typedef enum TXFM_OPT { - TXFM_OPT_NORMAL, - TXFM_OPT_DC -} TXFM_OPT; - struct optimize_ctx { ENTROPY_CONTEXT ta[MAX_MB_PLANE][16]; ENTROPY_CONTEXT tl[MAX_MB_PLANE][16]; @@ -311,337 +307,6 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block, return final_eob; } -static INLINE void fdct32x32(int rd_transform, - const int16_t *src, tran_low_t *dst, - int src_stride) { - if (rd_transform) - vpx_fdct32x32_rd(src, dst, src_stride); - else - vpx_fdct32x32(src, dst, src_stride); -} - -#if CONFIG_VP9_HIGHBITDEPTH -static INLINE void highbd_fdct32x32(int rd_transform, const int16_t *src, - tran_low_t *dst, int src_stride) { - if (rd_transform) - vpx_highbd_fdct32x32_rd(src, dst, src_stride); - else - vpx_highbd_fdct32x32(src, dst, src_stride); -} -#endif // CONFIG_VP9_HIGHBITDEPTH - -#if CONFIG_EXT_TX -// Forward identity transform. -static void fwd_idtx_c(const int16_t *src_diff, tran_low_t *coeff, int stride, - int bs) { - int r, c; - const int shift = bs < 32 ? 3 : 2; - - for (r = 0; r < bs; ++r) { - for (c = 0; c < bs; ++c) - coeff[c] = src_diff[c] << shift; - src_diff += stride; - coeff += bs; - } -} -#endif // CONFIG_EXT_TX - -void vp10_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, int lossless) { - if (lossless) { - assert(tx_type == DCT_DCT); - vp10_fwht4x4(src_diff, coeff, diff_stride); - return; - } - - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - vp10_fht4x4(src_diff, coeff, diff_stride, tx_type); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_fht4x4(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_fht4x4_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 4); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, void* opt_data) { - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - if (opt_data == (void*)TXFM_OPT_NORMAL) - vp10_fht8x8(src_diff, coeff, diff_stride, tx_type); - else // TXFM_OPT_DC - vpx_fdct8x8_1(src_diff, coeff, diff_stride); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_fht8x8(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_fht8x8_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 8); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, void* opt_data) { - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - if (opt_data == (void*)TXFM_OPT_NORMAL) - vp10_fht16x16(src_diff, coeff, diff_stride, tx_type); - else // TXFM_OPT_DC - vpx_fdct16x16_1(src_diff, coeff, diff_stride); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_fht16x16(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_fht16x16_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 16); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void fwd_txfm_32x32(int rd_transform, const int16_t *src_diff, - tran_low_t *coeff, int diff_stride, - TX_TYPE tx_type, void* opt_data) { - switch (tx_type) { - case DCT_DCT: - if (opt_data == (void*)TXFM_OPT_NORMAL) - fdct32x32(rd_transform, src_diff, coeff, diff_stride); - else // TXFM_OPT_DC - vpx_fdct32x32_1(src_diff, coeff, diff_stride); - break; -#if CONFIG_EXT_TX - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 32); - break; -#endif // CONFIG_EXT_TX - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - assert(0); - break; - default: - assert(0); - break; - } -} - -#if CONFIG_VP9_HIGHBITDEPTH -void vp10_highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, int lossless) { - if (lossless) { - assert(tx_type == DCT_DCT); - vp10_highbd_fwht4x4(src_diff, coeff, diff_stride); - return; - } - - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - vp10_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_highbd_fht4x4_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 4); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void highbd_fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, void* opt_data) { - (void)opt_data; - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - vp10_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_highbd_fht8x8_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 8); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void highbd_fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, void* opt_data) { - (void)opt_data; - switch (tx_type) { - case DCT_DCT: - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - vp10_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type); - break; -#if CONFIG_EXT_TX - case FLIPADST_DCT: - case DCT_FLIPADST: - case FLIPADST_FLIPADST: - case ADST_FLIPADST: - case FLIPADST_ADST: - vp10_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type); - break; - case DST_DST: - case DCT_DST: - case DST_DCT: - case DST_ADST: - case ADST_DST: - case DST_FLIPADST: - case FLIPADST_DST: - // Use C version since DST exists only in C - vp10_highbd_fht16x16_c(src_diff, coeff, diff_stride, tx_type); - break; - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 16); - break; -#endif // CONFIG_EXT_TX - default: - assert(0); - break; - } -} - -static void highbd_fwd_txfm_32x32(int rd_transform, const int16_t *src_diff, - tran_low_t *coeff, int diff_stride, - TX_TYPE tx_type, void* opt_data) { - switch (tx_type) { - case DCT_DCT: - if (opt_data == (void*)TXFM_OPT_NORMAL) - highbd_fdct32x32(rd_transform, src_diff, coeff, diff_stride); - else // TXFM_OPT_DC - vpx_highbd_fdct32x32_1(src_diff, coeff, diff_stride); - break; -#if CONFIG_EXT_TX - case IDTX: - fwd_idtx_c(src_diff, coeff, diff_stride, 32); - break; -#endif // CONFIG_EXT_TX - case ADST_DCT: - case DCT_ADST: - case ADST_ADST: - assert(0); - break; - default: - assert(0); - break; - } -} -#endif // CONFIG_VP9_HIGHBITDEPTH - void vp10_xform_quant_fp(MACROBLOCK *x, int plane, int block, int blk_row, int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size) { @@ -658,14 +323,21 @@ void vp10_xform_quant_fp(MACROBLOCK *x, int plane, int block, uint16_t *const eob = &p->eobs[block]; const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize]; const int16_t *src_diff; + + FWD_TXFM_PARAM fwd_txfm_param; + fwd_txfm_param.tx_type = get_tx_type(plane_type, xd, block, tx_size); + fwd_txfm_param.tx_size = tx_size; + fwd_txfm_param.fwd_txfm_opt = FWD_TXFM_OPT_NORMAL; + fwd_txfm_param.rd_transform = x->use_lp32x32fdct; + fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id]; + src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)]; #if CONFIG_VP9_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { + highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); switch (tx_size) { case TX_32X32: - highbd_fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride, - tx_type, (void*)TXFM_OPT_NORMAL); vp10_highbd_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, @@ -673,22 +345,18 @@ void vp10_xform_quant_fp(MACROBLOCK *x, int plane, int block, scan_order->iscan); break; case TX_16X16: - highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vp10_highbd_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_8X8: - highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vp10_highbd_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_4X4: - vp10_highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vp10_highbd_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -701,31 +369,27 @@ void vp10_xform_quant_fp(MACROBLOCK *x, int plane, int block, } #endif // CONFIG_VP9_HIGHBITDEPTH + fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); switch (tx_size) { case TX_32X32: - fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vp10_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_16X16: - fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vp10_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_8X8: - fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vp10_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_4X4: - vp10_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vp10_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp, p->quant_fp, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -744,39 +408,42 @@ void vp10_xform_quant_dc(MACROBLOCK *x, int plane, int block, const struct macroblock_plane *const p = &x->plane[plane]; const struct macroblockd_plane *const pd = &xd->plane[plane]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV; - TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size); tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); uint16_t *const eob = &p->eobs[block]; const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize]; const int16_t *src_diff; + + FWD_TXFM_PARAM fwd_txfm_param; + fwd_txfm_param.tx_type = get_tx_type(plane_type, xd, block, tx_size); + fwd_txfm_param.tx_size = tx_size; + fwd_txfm_param.fwd_txfm_opt = FWD_TXFM_OPT_DC; + fwd_txfm_param.rd_transform = 0; + fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id]; + src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)]; #if CONFIG_VP9_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { + highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); switch (tx_size) { case TX_32X32: - highbd_fwd_txfm_32x32(0, src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_highbd_quantize_dc_32x32(coeff, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_16X16: - highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_highbd_quantize_dc(coeff, 256, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_8X8: - highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_highbd_quantize_dc(coeff, 64, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_4X4: - vp10_highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vpx_highbd_quantize_dc(coeff, 16, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); @@ -788,28 +455,24 @@ void vp10_xform_quant_dc(MACROBLOCK *x, int plane, int block, } #endif // CONFIG_VP9_HIGHBITDEPTH + fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); switch (tx_size) { case TX_32X32: - fwd_txfm_32x32(0, src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_quantize_dc_32x32(coeff, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_16X16: - fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_quantize_dc(coeff, 256, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_8X8: - fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_DC); vpx_quantize_dc(coeff, 64, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); break; case TX_4X4: - vp10_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vpx_quantize_dc(coeff, 16, x->skip_block, p->round, p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0], eob); @@ -836,36 +499,39 @@ void vp10_xform_quant(MACROBLOCK *x, int plane, int block, uint16_t *const eob = &p->eobs[block]; const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize]; const int16_t *src_diff; + + FWD_TXFM_PARAM fwd_txfm_param; + fwd_txfm_param.tx_type = get_tx_type(plane_type, xd, block, tx_size); + fwd_txfm_param.tx_size = tx_size; + fwd_txfm_param.fwd_txfm_opt = FWD_TXFM_OPT_NORMAL; + fwd_txfm_param.rd_transform = x->use_lp32x32fdct; + fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id]; + src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)]; #if CONFIG_VP9_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - switch (tx_size) { + highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); + switch (tx_size) { case TX_32X32: - highbd_fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride, - tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_16X16: - highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_8X8: - highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_4X4: - vp10_highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vpx_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -878,31 +544,27 @@ void vp10_xform_quant(MACROBLOCK *x, int plane, int block, } #endif // CONFIG_VP9_HIGHBITDEPTH + fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); switch (tx_size) { case TX_32X32: - fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_16X16: - fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_8X8: - fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, scan_order->iscan); break; case TX_4X4: - vp10_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[xd->mi[0]->mbmi.segment_id]); vpx_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -1255,7 +917,7 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV; - TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size); + const TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size); const scan_order *const scan_order = get_scan(tx_size, tx_type, 0); PREDICTION_MODE mode; const int bwl = b_width_log2_lookup[plane_bsize]; @@ -1266,6 +928,16 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, uint16_t *eob = &p->eobs[block]; const int src_stride = p->src.stride; const int dst_stride = pd->dst.stride; + + int tx1d_size = get_tx1d_size(tx_size); + + FWD_TXFM_PARAM fwd_txfm_param; + fwd_txfm_param.tx_type = tx_type; + fwd_txfm_param.tx_size = tx_size; + fwd_txfm_param.fwd_txfm_opt = FWD_TXFM_OPT_NORMAL; + fwd_txfm_param.rd_transform = x->use_lp32x32fdct; + fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id]; + dst = &pd->dst.buf[4 * (blk_row * dst_stride + blk_col)]; src = &p->src.buf[4 * (blk_row * src_stride + blk_col)]; src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)]; @@ -1276,13 +948,13 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, #if CONFIG_VP9_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { + vpx_highbd_subtract_block(tx1d_size, tx1d_size, src_diff, diff_stride, + src, src_stride, dst, dst_stride, xd->bd); + highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); + switch (tx_size) { case TX_32X32: if (!x->skip_recode) { - vpx_highbd_subtract_block(32, 32, src_diff, diff_stride, - src, src_stride, dst, dst_stride, xd->bd); - highbd_fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, - diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -1294,9 +966,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_16X16: if (!x->skip_recode) { - vpx_highbd_subtract_block(16, 16, src_diff, diff_stride, - src, src_stride, dst, dst_stride, xd->bd); - highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -1308,9 +977,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_8X8: if (!x->skip_recode) { - vpx_highbd_subtract_block(8, 8, src_diff, diff_stride, - src, src_stride, dst, dst_stride, xd->bd); - highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -1322,10 +988,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_4X4: if (!x->skip_recode) { - vpx_highbd_subtract_block(4, 4, src_diff, diff_stride, - src, src_stride, dst, dst_stride, xd->bd); - vp10_highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[mbmi->segment_id]); vpx_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, @@ -1349,13 +1011,13 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, } #endif // CONFIG_VP9_HIGHBITDEPTH + vpx_subtract_block(tx1d_size, tx1d_size, src_diff, diff_stride, + src, src_stride, dst, dst_stride); + fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param); + switch (tx_size) { case TX_32X32: if (!x->skip_recode) { - vpx_subtract_block(32, 32, src_diff, diff_stride, - src, src_stride, dst, dst_stride); - fwd_txfm_32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride, - tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, @@ -1366,9 +1028,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_16X16: if (!x->skip_recode) { - vpx_subtract_block(16, 16, src_diff, diff_stride, - src, src_stride, dst, dst_stride); - fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, @@ -1379,9 +1038,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_8X8: if (!x->skip_recode) { - vpx_subtract_block(8, 8, src_diff, diff_stride, - src, src_stride, dst, dst_stride); - fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, (void*)TXFM_OPT_NORMAL); vpx_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, @@ -1392,10 +1048,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, break; case TX_4X4: if (!x->skip_recode) { - vpx_subtract_block(4, 4, src_diff, diff_stride, - src, src_stride, dst, dst_stride); - vp10_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, - xd->lossless[mbmi->segment_id]); vpx_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round, p->quant, p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan, diff --git a/vp10/encoder/encodemb.h b/vp10/encoder/encodemb.h index 2e6516e0b..3e5bce3c6 100644 --- a/vp10/encoder/encodemb.h +++ b/vp10/encoder/encodemb.h @@ -43,14 +43,6 @@ void vp10_encode_block_intra(int plane, int block, int blk_row, int blk_col, void vp10_encode_intra_block_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane); -void vp10_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, int lossless); - -#if CONFIG_VP9_HIGHBITDEPTH -void vp10_highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, - int diff_stride, TX_TYPE tx_type, int lossless); -#endif // CONFIG_VP9_HIGHBITDEPTH - #ifdef __cplusplus } // extern "C" #endif diff --git a/vp10/encoder/hybrid_fwd_txfm.c b/vp10/encoder/hybrid_fwd_txfm.c new file mode 100644 index 000000000..8b482764e --- /dev/null +++ b/vp10/encoder/hybrid_fwd_txfm.c @@ -0,0 +1,406 @@ +/* + * Copyright (c) 2015 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "./vp10_rtcd.h" +#include "./vpx_config.h" +#include "./vpx_dsp_rtcd.h" + +#include "vp10/common/idct.h" +#include "vp10/encoder/hybrid_fwd_txfm.h" + +static INLINE void fdct32x32(int rd_transform, const int16_t *src, + tran_low_t *dst, int src_stride) { + if (rd_transform) + vpx_fdct32x32_rd(src, dst, src_stride); + else + vpx_fdct32x32(src, dst, src_stride); +} + +#if CONFIG_VP9_HIGHBITDEPTH +static INLINE void highbd_fdct32x32(int rd_transform, const int16_t *src, + tran_low_t *dst, int src_stride) { + if (rd_transform) + vpx_highbd_fdct32x32_rd(src, dst, src_stride); + else + vpx_highbd_fdct32x32(src, dst, src_stride); +} +#endif // CONFIG_VP9_HIGHBITDEPTH + +#if CONFIG_EXT_TX +// Forward identity transform. +static void fwd_idtx_c(const int16_t *src_diff, tran_low_t *coeff, int stride, + int bs) { + int r, c; + const int shift = bs < 32 ? 3 : 2; + + for (r = 0; r < bs; ++r) { + for (c = 0; c < bs; ++c) coeff[c] = src_diff[c] << shift; + src_diff += stride; + coeff += bs; + } +} +#endif // CONFIG_EXT_TX + +void vp10_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, int lossless) { + if (lossless) { + assert(tx_type == DCT_DCT); + vp10_fwht4x4(src_diff, coeff, diff_stride); + return; + } + + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + vp10_fht4x4(src_diff, coeff, diff_stride, tx_type); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_fht4x4(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_fht4x4_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 4); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, + FWD_TXFM_OPT fwd_txfm_opt) { + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + if (fwd_txfm_opt == FWD_TXFM_OPT_NORMAL) + vp10_fht8x8(src_diff, coeff, diff_stride, tx_type); + else // FWD_TXFM_OPT_DC + vpx_fdct8x8_1(src_diff, coeff, diff_stride); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_fht8x8(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_fht8x8_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 8); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, + FWD_TXFM_OPT fwd_txfm_opt) { + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + if (fwd_txfm_opt == FWD_TXFM_OPT_NORMAL) + vp10_fht16x16(src_diff, coeff, diff_stride, tx_type); + else // FWD_TXFM_OPT_DC + vpx_fdct16x16_1(src_diff, coeff, diff_stride); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_fht16x16(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_fht16x16_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 16); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void fwd_txfm_32x32(int rd_transform, const int16_t *src_diff, + tran_low_t *coeff, int diff_stride, TX_TYPE tx_type, + FWD_TXFM_OPT fwd_txfm_opt) { + switch (tx_type) { + case DCT_DCT: + if (fwd_txfm_opt == FWD_TXFM_OPT_NORMAL) + fdct32x32(rd_transform, src_diff, coeff, diff_stride); + else // FWD_TXFM_OPT_DC + vpx_fdct32x32_1(src_diff, coeff, diff_stride); + break; +#if CONFIG_EXT_TX + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 32); + break; +#endif // CONFIG_EXT_TX + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + assert(0); + break; + default: + assert(0); + break; + } +} + +#if CONFIG_VP9_HIGHBITDEPTH +void vp10_highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, int lossless) { + if (lossless) { + assert(tx_type == DCT_DCT); + vp10_highbd_fwht4x4(src_diff, coeff, diff_stride); + return; + } + + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + vp10_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_highbd_fht4x4_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 4); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void highbd_fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, + FWD_TXFM_OPT fwd_txfm_opt) { + (void)fwd_txfm_opt; + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + vp10_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_highbd_fht8x8_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 8); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void highbd_fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, + FWD_TXFM_OPT fwd_txfm_opt) { + (void)fwd_txfm_opt; + switch (tx_type) { + case DCT_DCT: + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + vp10_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type); + break; +#if CONFIG_EXT_TX + case FLIPADST_DCT: + case DCT_FLIPADST: + case FLIPADST_FLIPADST: + case ADST_FLIPADST: + case FLIPADST_ADST: + vp10_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type); + break; + case DST_DST: + case DCT_DST: + case DST_DCT: + case DST_ADST: + case ADST_DST: + case DST_FLIPADST: + case FLIPADST_DST: + // Use C version since DST exists only in C + vp10_highbd_fht16x16_c(src_diff, coeff, diff_stride, tx_type); + break; + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 16); + break; +#endif // CONFIG_EXT_TX + default: + assert(0); + break; + } +} + +static void highbd_fwd_txfm_32x32(int rd_transform, const int16_t *src_diff, + tran_low_t *coeff, int diff_stride, + TX_TYPE tx_type, FWD_TXFM_OPT fwd_txfm_opt) { + switch (tx_type) { + case DCT_DCT: + if (fwd_txfm_opt == FWD_TXFM_OPT_NORMAL) + highbd_fdct32x32(rd_transform, src_diff, coeff, diff_stride); + else // FWD_TXFM_OPT_DC + vpx_highbd_fdct32x32_1(src_diff, coeff, diff_stride); + break; +#if CONFIG_EXT_TX + case IDTX: + fwd_idtx_c(src_diff, coeff, diff_stride, 32); + break; +#endif // CONFIG_EXT_TX + case ADST_DCT: + case DCT_ADST: + case ADST_ADST: + assert(0); + break; + default: + assert(0); + break; + } +} +#endif // CONFIG_VP9_HIGHBITDEPTH + +void fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, int diff_stride, + FWD_TXFM_PARAM *fwd_txfm_param) { + const int fwd_txfm_opt = fwd_txfm_param->fwd_txfm_opt; + const TX_TYPE tx_type = fwd_txfm_param->tx_type; + const TX_SIZE tx_size = fwd_txfm_param->tx_size; + const int rd_transform = fwd_txfm_param->rd_transform; + const int lossless = fwd_txfm_param->lossless; + switch (tx_size) { + case TX_32X32: + fwd_txfm_32x32(rd_transform, src_diff, coeff, diff_stride, tx_type, + fwd_txfm_opt); + break; + case TX_16X16: + fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, fwd_txfm_opt); + break; + case TX_8X8: + fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, fwd_txfm_opt); + break; + case TX_4X4: + vp10_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, lossless); + break; + default: + assert(0); + break; + } +} + +#if CONFIG_VP9_HIGHBITDEPTH +void highbd_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, FWD_TXFM_PARAM *fwd_txfm_param) { + const int fwd_txfm_opt = fwd_txfm_param->fwd_txfm_opt; + const TX_TYPE tx_type = fwd_txfm_param->tx_type; + const TX_SIZE tx_size = fwd_txfm_param->tx_size; + const int rd_transform = fwd_txfm_param->rd_transform; + const int lossless = fwd_txfm_param->lossless; + switch (tx_size) { + case TX_32X32: + highbd_fwd_txfm_32x32(rd_transform, src_diff, coeff, diff_stride, tx_type, + fwd_txfm_opt); + break; + case TX_16X16: + highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, tx_type, + fwd_txfm_opt); + break; + case TX_8X8: + highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, tx_type, fwd_txfm_opt); + break; + case TX_4X4: + vp10_highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, tx_type, lossless); + break; + default: + assert(0); + break; + } +} +#endif // CONFIG_VP9_HIGHBITDEPTH diff --git a/vp10/encoder/hybrid_fwd_txfm.h b/vp10/encoder/hybrid_fwd_txfm.h new file mode 100644 index 000000000..62b8d5acb --- /dev/null +++ b/vp10/encoder/hybrid_fwd_txfm.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2015 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef VP10_ENCODER_HYBRID_FWD_TXFM_H_ +#define VP10_ENCODER_HYBRID_FWD_TXFM_H_ + +#include "./vpx_config.h" + +typedef enum FWD_TXFM_OPT { FWD_TXFM_OPT_NORMAL, FWD_TXFM_OPT_DC } FWD_TXFM_OPT; + +typedef struct FWD_TXFM_PARAM { + TX_TYPE tx_type; + TX_SIZE tx_size; + FWD_TXFM_OPT fwd_txfm_opt; + int rd_transform; + int lossless; +} FWD_TXFM_PARAM; + +#ifdef __cplusplus +extern "C" { +#endif + +void fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, int diff_stride, + FWD_TXFM_PARAM *fwd_txfm_param); +void vp10_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, int lossless); + +#if CONFIG_VP9_HIGHBITDEPTH +void highbd_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, FWD_TXFM_PARAM *fwd_txfm_param); +void vp10_highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff, + int diff_stride, TX_TYPE tx_type, int lossless); +#endif // CONFIG_VP9_HIGHBITDEPTH + +static INLINE int get_tx1d_size(TX_SIZE tx_size) { + switch (tx_size) { + case TX_32X32: + return 32; + case TX_16X16: + return 16; + case TX_8X8: + return 8; + case TX_4X4: + return 4; + default: + assert(0); + return -1; + } +} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // VP10_ENCODER_HYBRID_FWD_TXFM_H_ diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c index 1f2378451..7fff6e394 100644 --- a/vp10/encoder/rdopt.c +++ b/vp10/encoder/rdopt.c @@ -35,6 +35,7 @@ #include "vp10/encoder/encodemb.h" #include "vp10/encoder/encodemv.h" #include "vp10/encoder/encoder.h" +#include "vp10/encoder/hybrid_fwd_txfm.h" #include "vp10/encoder/mcomp.h" #include "vp10/encoder/palette.h" #include "vp10/encoder/quantize.h" diff --git a/vp10/vp10cx.mk b/vp10/vp10cx.mk index 7b77f314e..272650da6 100644 --- a/vp10/vp10cx.mk +++ b/vp10/vp10cx.mk @@ -24,6 +24,8 @@ 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/hybrid_fwd_txfm.c +VP10_CX_SRCS-yes += encoder/hybrid_fwd_txfm.h VP10_CX_SRCS-$(CONFIG_VP9_TEMPORAL_DENOISING) += encoder/denoiser.c VP10_CX_SRCS-$(CONFIG_VP9_TEMPORAL_DENOISING) += encoder/denoiser.h VP10_CX_SRCS-yes += encoder/encodeframe.c -- 2.50.1