generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor get_tx_type and get_scan

Browse Source 
This makes it easier to add new transform types and scan orders
to VP10 in the future.

Change-Id: I94874ddc9b19928d7820d57e94e2af04adf51efe
This commit is contained in:
hui su 2015-08-18 16:57:07 -07:00
parent b1339751b9
commit 5eed74e1d3
7 changed files with 47 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
vp10/common/blockd.h
View File

@ -218,24 +218,16 @@ static const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
ADST_ADST, // TM ADST_ADST, // TM
}; };
static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type, static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type, const MACROBLOCKD *xd,
const MACROBLOCKD *xd) { int block_idx) {
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi))
return DCT_DCT;
return intra_mode_to_tx_type_lookup[mbmi->mode];
}
static INLINE TX_TYPE get_tx_type_4x4(PLANE_TYPE plane_type,
const MACROBLOCKD *xd, int ib) {
const MODE_INFO *const mi = xd->mi[0]; const MODE_INFO *const mi = xd->mi[0];
const MB_MODE_INFO *const mbmi = &mi->mbmi;
if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(&mi->mbmi)) if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi) ||
mbmi->tx_size >= TX_32X32)
return DCT_DCT; return DCT_DCT;
return intra_mode_to_tx_type_lookup[get_y_mode(mi, ib)]; return intra_mode_to_tx_type_lookup[get_y_mode(mi, block_idx)];
} }
void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y); void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);

12
vp10/common/scan.h
View File

@ -38,16 +38,8 @@ static INLINE int get_coef_context(const int16_t *neighbors,
token_cache[neighbors[MAX_NEIGHBORS * c + 1]]) >> 1; token_cache[neighbors[MAX_NEIGHBORS * c + 1]]) >> 1;
} }
static INLINE const scan_order *get_scan(const MACROBLOCKD *xd, TX_SIZE tx_size, static INLINE const scan_order *get_scan(TX_SIZE tx_size, TX_TYPE tx_type) {
PLANE_TYPE type, int block_idx) { return &vp10_scan_orders[tx_size][tx_type];
const MODE_INFO *const mi = xd->mi[0];
if (is_inter_block(&mi->mbmi) || type != PLANE_TYPE_Y || xd->lossless) {
return &vp10_default_scan_orders[tx_size];
} else {
const PREDICTION_MODE mode = get_y_mode(mi, block_idx);
return &vp10_scan_orders[tx_size][intra_mode_to_tx_type_lookup[mode]];
}
} }
#ifdef __cplusplus #ifdef __cplusplus

13
vp10/decoder/decodeframe.c
View File

@ -370,7 +370,9 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
TX_SIZE tx_size) { TX_SIZE tx_size) {
struct macroblockd_plane *const pd = &xd->plane[plane]; struct macroblockd_plane *const pd = &xd->plane[plane];
PREDICTION_MODE mode = (plane == 0) ? mbmi->mode : mbmi->uv_mode; PREDICTION_MODE mode = (plane == 0) ? mbmi->mode : mbmi->uv_mode;
PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
uint8_t *dst; uint8_t *dst;
int block_idx = (row << 1) + col;
dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col]; dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col];
if (mbmi->sb_type < BLOCK_8X8) if (mbmi->sb_type < BLOCK_8X8)
@ -382,10 +384,8 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
col, row, plane); col, row, plane);
if (!mbmi->skip) { if (!mbmi->skip) {
const TX_TYPE tx_type = (plane || xd->lossless) ? TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx);
DCT_DCT : intra_mode_to_tx_type_lookup[mode]; const scan_order *sc = get_scan(tx_size, tx_type);
const scan_order *sc = (plane || xd->lossless) ?
&vp10_default_scan_orders[tx_size] : &vp10_scan_orders[tx_size][tx_type];
const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size, const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size,
r, mbmi->segment_id); r, mbmi->segment_id);
inverse_transform_block_intra(xd, plane, tx_type, tx_size, inverse_transform_block_intra(xd, plane, tx_type, tx_size,
@ -397,7 +397,10 @@ static int reconstruct_inter_block(MACROBLOCKD *const xd, vpx_reader *r,
MB_MODE_INFO *const mbmi, int plane, MB_MODE_INFO *const mbmi, int plane,
int row, int col, TX_SIZE tx_size) { int row, int col, TX_SIZE tx_size) {
struct macroblockd_plane *const pd = &xd->plane[plane]; struct macroblockd_plane *const pd = &xd->plane[plane];
const scan_order *sc = &vp10_default_scan_orders[tx_size]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
int block_idx = (row << 1) + col;
TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx);
const scan_order *sc = get_scan(tx_size, tx_type);
const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size, r, const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size, r,
mbmi->segment_id); mbmi->segment_id);

29
vp10/encoder/encodemb.c
View File

@ -104,7 +104,8 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block,
const int mul = 1 + (tx_size == TX_32X32); const int mul = 1 + (tx_size == TX_32X32);
const int16_t *dequant_ptr = pd->dequant; const int16_t *dequant_ptr = pd->dequant;
const uint8_t *const band_translate = get_band_translate(tx_size); const uint8_t *const band_translate = get_band_translate(tx_size);
const scan_order *const so = get_scan(xd, tx_size, type, block); TX_TYPE tx_type = get_tx_type(type, xd, block);
const scan_order *const so = get_scan(tx_size, tx_type);
const int16_t *const scan = so->scan; const int16_t *const scan = so->scan;
const int16_t *const nb = so->neighbors; const int16_t *const nb = so->neighbors;
int next = eob, sz = 0; int next = eob, sz = 0;
@ -327,7 +328,9 @@ void vp10_xform_quant_fp(MACROBLOCK *x, int plane, int block,
MACROBLOCKD *const xd = &x->e_mbd; MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblock_plane *const p = &x->plane[plane]; const struct macroblock_plane *const p = &x->plane[plane];
const struct macroblockd_plane *const pd = &xd->plane[plane]; const struct macroblockd_plane *const pd = &xd->plane[plane];
const scan_order *const scan_order = &vp10_default_scan_orders[tx_size]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
TX_TYPE tx_type = get_tx_type(plane_type, xd, block);
const scan_order *const scan_order = get_scan(tx_size, tx_type);
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
@ -498,7 +501,9 @@ void vp10_xform_quant(MACROBLOCK *x, int plane, int block,
MACROBLOCKD *const xd = &x->e_mbd; MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblock_plane *const p = &x->plane[plane]; const struct macroblock_plane *const p = &x->plane[plane];
const struct macroblockd_plane *const pd = &xd->plane[plane]; const struct macroblockd_plane *const pd = &xd->plane[plane];
const scan_order *const scan_order = &vp10_default_scan_orders[tx_size]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
TX_TYPE tx_type = get_tx_type(plane_type, xd, block);
const scan_order *const scan_order = get_scan(tx_size, tx_type);
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
@ -772,8 +777,9 @@ void vp10_encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
tran_low_t *coeff = BLOCK_OFFSET(p->coeff, block); tran_low_t *coeff = BLOCK_OFFSET(p->coeff, block);
tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block);
tran_low_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); tran_low_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
const scan_order *scan_order; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
TX_TYPE tx_type = DCT_DCT; TX_TYPE tx_type = get_tx_type(plane_type, xd, block);
const scan_order *const scan_order = get_scan(tx_size, tx_type);
PREDICTION_MODE mode; PREDICTION_MODE mode;
const int bwl = b_width_log2_lookup[plane_bsize]; const int bwl = b_width_log2_lookup[plane_bsize];
const int diff_stride = 4 * (1 << bwl); const int diff_stride = 4 * (1 << bwl);
@ -788,20 +794,7 @@ void vp10_encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
src = &p->src.buf[4 * (j * src_stride + i)]; src = &p->src.buf[4 * (j * src_stride + i)];
src_diff = &p->src_diff[4 * (j * diff_stride + i)]; src_diff = &p->src_diff[4 * (j * diff_stride + i)];
if (tx_size == TX_4X4) {
tx_type = get_tx_type_4x4(pd->plane_type, xd, block);
scan_order = &vp10_scan_orders[TX_4X4][tx_type];
mode = plane == 0 ? get_y_mode(xd->mi[0], block) : mbmi->uv_mode; mode = plane == 0 ? get_y_mode(xd->mi[0], block) : mbmi->uv_mode;
} else {
mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
if (tx_size == TX_32X32) {
scan_order = &vp10_default_scan_orders[TX_32X32];
} else {
tx_type = get_tx_type(pd->plane_type, xd);
scan_order = &vp10_scan_orders[tx_size][tx_type];
}
}
vp10_predict_intra_block(xd, bwl, tx_size, mode, x->skip_encode ? src : dst, vp10_predict_intra_block(xd, bwl, tx_size, mode, x->skip_encode ? src : dst,
x->skip_encode ? src_stride : dst_stride, x->skip_encode ? src_stride : dst_stride,
dst, dst_stride, i, j, plane); dst, dst_stride, i, j, plane);

4
vp10/encoder/pickmode.c
View File

@ -600,7 +600,9 @@ static void block_yrd(VP10_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
for (r = 0; r < max_blocks_high; r += block_step) { for (r = 0; r < max_blocks_high; r += block_step) {
for (c = 0; c < num_4x4_w; c += block_step) { for (c = 0; c < num_4x4_w; c += block_step) {
if (c < max_blocks_wide) { if (c < max_blocks_wide) {
const scan_order *const scan_order = &vp10_default_scan_orders[tx_size]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
TX_TYPE tx_type = get_tx_type(plane_type, xd, block);
const scan_order *const scan_order = get_scan(tx_size, tx_type);
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);

21
vp10/encoder/rdopt.c
View File

@ -557,6 +557,7 @@ static void txfm_rd_in_plane(MACROBLOCK *x,
int use_fast_coef_casting) { int use_fast_coef_casting) {
MACROBLOCKD *const xd = &x->e_mbd; MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblockd_plane *const pd = &xd->plane[plane]; const struct macroblockd_plane *const pd = &xd->plane[plane];
TX_TYPE tx_type;
struct rdcost_block_args args; struct rdcost_block_args args;
vp10_zero(args); vp10_zero(args);
args.x = x; args.x = x;
@ -569,7 +570,8 @@ static void txfm_rd_in_plane(MACROBLOCK *x,
vp10_get_entropy_contexts(bsize, tx_size, pd, args.t_above, args.t_left); vp10_get_entropy_contexts(bsize, tx_size, pd, args.t_above, args.t_left);
args.so = get_scan(xd, tx_size, pd->plane_type, 0); tx_type = get_tx_type(pd->plane_type, xd, 0);
args.so = get_scan(tx_size, tx_type);
vp10_foreach_transformed_block_in_plane(xd, bsize, plane, vp10_foreach_transformed_block_in_plane(xd, bsize, plane,
block_rd_txfm, &args); block_rd_txfm, &args);
@ -795,7 +797,8 @@ static int64_t rd_pick_intra4x4block(VP10_COMP *cpi, MACROBLOCK *x,
vpx_highbd_subtract_block(4, 4, src_diff, 8, src, src_stride, vpx_highbd_subtract_block(4, 4, src_diff, 8, src, src_stride,
dst, dst_stride, xd->bd); dst, dst_stride, xd->bd);
if (xd->lossless) { if (xd->lossless) {
const scan_order *so = &vp10_default_scan_orders[TX_4X4]; TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block);
const scan_order *so = get_scan(TX_4X4, tx_type);
vp10_highbd_fwht4x4(src_diff, coeff, 8); vp10_highbd_fwht4x4(src_diff, coeff, 8);
vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan); vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan);
ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4, ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4,
@ -808,8 +811,8 @@ static int64_t rd_pick_intra4x4block(VP10_COMP *cpi, MACROBLOCK *x,
p->eobs[block], xd->bd); p->eobs[block], xd->bd);
} else { } else {
int64_t unused; int64_t unused;
const TX_TYPE tx_type = get_tx_type_4x4(PLANE_TYPE_Y, xd, block); TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block);
const scan_order *so = &vp10_scan_orders[TX_4X4][tx_type]; const scan_order *so = get_scan(TX_4X4, tx_type);
if (tx_type == DCT_DCT) if (tx_type == DCT_DCT)
vpx_highbd_fdct4x4(src_diff, coeff, 8); vpx_highbd_fdct4x4(src_diff, coeff, 8);
else else
@ -897,7 +900,8 @@ static int64_t rd_pick_intra4x4block(VP10_COMP *cpi, MACROBLOCK *x,
vpx_subtract_block(4, 4, src_diff, 8, src, src_stride, dst, dst_stride); vpx_subtract_block(4, 4, src_diff, 8, src, src_stride, dst, dst_stride);
if (xd->lossless) { if (xd->lossless) {
const scan_order *so = &vp10_default_scan_orders[TX_4X4]; TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block);
const scan_order *so = get_scan(TX_4X4, tx_type);
vp10_fwht4x4(src_diff, coeff, 8); vp10_fwht4x4(src_diff, coeff, 8);
vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan); vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan);
ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4, ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4,
@ -909,8 +913,8 @@ static int64_t rd_pick_intra4x4block(VP10_COMP *cpi, MACROBLOCK *x,
p->eobs[block]); p->eobs[block]);
} else { } else {
int64_t unused; int64_t unused;
const TX_TYPE tx_type = get_tx_type_4x4(PLANE_TYPE_Y, xd, block); TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block);
const scan_order *so = &vp10_scan_orders[TX_4X4][tx_type]; const scan_order *so = get_scan(TX_4X4, tx_type);
vp10_fht4x4(src_diff, coeff, 8, tx_type); vp10_fht4x4(src_diff, coeff, 8, tx_type);
vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan); vp10_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan);
ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4, ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4,
@ -1301,7 +1305,8 @@ static int64_t encode_inter_mb_segment(VP10_COMP *cpi,
pd->dst.stride)]; pd->dst.stride)];
int64_t thisdistortion = 0, thissse = 0; int64_t thisdistortion = 0, thissse = 0;
int thisrate = 0, ref; int thisrate = 0, ref;
const scan_order *so = &vp10_default_scan_orders[TX_4X4]; TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, i);
const scan_order *so = get_scan(TX_4X4, tx_type);
const int is_compound = has_second_ref(&mi->mbmi); const int is_compound = has_second_ref(&mi->mbmi);
const InterpKernel *kernel = vp10_filter_kernels[mi->mbmi.interp_filter]; const InterpKernel *kernel = vp10_filter_kernels[mi->mbmi.interp_filter];

4
vp10/encoder/tokenize.c
View File

@ -507,7 +507,8 @@ static void tokenize_b(int plane, int block, BLOCK_SIZE plane_bsize,
const tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block); const tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block);
const int segment_id = mbmi->segment_id; const int segment_id = mbmi->segment_id;
const int16_t *scan, *nb; const int16_t *scan, *nb;
const scan_order *so; const TX_TYPE tx_type = get_tx_type(type, xd, block);
const scan_order *const so = get_scan(tx_size, tx_type);
const int ref = is_inter_block(mbmi); const int ref = is_inter_block(mbmi);
unsigned int (*const counts)[COEFF_CONTEXTS][ENTROPY_TOKENS] = unsigned int (*const counts)[COEFF_CONTEXTS][ENTROPY_TOKENS] =
td->rd_counts.coef_counts[tx_size][type][ref]; td->rd_counts.coef_counts[tx_size][type][ref];
@ -524,7 +525,6 @@ static void tokenize_b(int plane, int block, BLOCK_SIZE plane_bsize,
pt = get_entropy_context(tx_size, pd->above_context + aoff, pt = get_entropy_context(tx_size, pd->above_context + aoff,
pd->left_context + loff); pd->left_context + loff);
so = get_scan(xd, tx_size, type, block);
scan = so->scan; scan = so->scan;
nb = so->neighbors; nb = so->neighbors;
c = 0; c = 0;