ref: 317d832d3827f74404b07225061d7e417d751dc8
parent: 127932e699b01d20bff003d6879298d1e5fbea46
parent: 120a878199ea5efb90cba873be82ecdbb9697f50
author: Dmitry Kovalev <dkovalev@google.com>
date: Fri May 31 11:28:45 EDT 2013
Merge "Adding plane_block_width and plane_block_height functions." into experimental
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -608,6 +608,16 @@
return res;
}
+static INLINE int plane_block_width(BLOCK_SIZE_TYPE bsize,
+ const struct macroblockd_plane* plane) {+ return 4 << (b_width_log2(bsize) - plane->subsampling_x);
+}
+
+static INLINE int plane_block_height(BLOCK_SIZE_TYPE bsize,
+ const struct macroblockd_plane* plane) {+ return 4 << (b_height_log2(bsize) - plane->subsampling_y);
+}
+
typedef void (*foreach_transformed_block_visitor)(int plane, int block,
BLOCK_SIZE_TYPE bsize,
int ss_txfrm_size,
@@ -678,8 +688,8 @@
// block sizes in number of 4x4 blocks log 2 ("*_b")// 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
// subsampled size of the block
- const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
- const int bh = b_height_log2(bsize) - xd->plane[plane].subsampling_y;
+ const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
+ const int bhl = b_height_log2(bsize) - xd->plane[plane].subsampling_y;
// size of the predictor to use.
int pred_w, pred_h;
@@ -689,21 +699,20 @@
pred_w = 0;
pred_h = 0;
} else {- pred_w = bw;
- pred_h = bh;
+ pred_w = bwl;
+ pred_h = bhl;
}
- assert(pred_w <= bw);
- assert(pred_h <= bh);
+ assert(pred_w <= bwl);
+ assert(pred_h <= bhl);
// visit each subblock in raster order
i = 0;
- for (y = 0; y < 1 << bh; y += 1 << pred_h) {- for (x = 0; x < 1 << bw; x += 1 << pred_w) {+ for (y = 0; y < 1 << bhl; y += 1 << pred_h) {+ for (x = 0; x < 1 << bwl; x += 1 << pred_w) {visit(plane, i, bsize, pred_w, pred_h, arg);
i += 1 << pred_w;
}
- i -= 1 << bw;
- i += 1 << (bw + pred_h);
+ i += (1 << (bwl + pred_h)) - (1 << bwl);
}
}
static INLINE void foreach_predicted_block(
@@ -733,8 +742,7 @@
static int16_t* raster_block_offset_int16(MACROBLOCKD *xd,
BLOCK_SIZE_TYPE bsize,
int plane, int block, int16_t *base) {- const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
- const int stride = 4 << bw;
+ const int stride = plane_block_width(bsize, &xd->plane[plane]);
return base + raster_block_offset(xd, bsize, plane, block, stride);
}
static uint8_t* raster_block_offset_uint8(MACROBLOCKD *xd,
--- a/vp9/common/vp9_reconinter.c
+++ b/vp9/common/vp9_reconinter.c
@@ -384,9 +384,8 @@
MACROBLOCKD * const xd = arg->xd;
const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
const int bhl = b_height_log2(bsize) - xd->plane[plane].subsampling_y;
- const int bh = 4 << bhl, bw = 4 << bwl;
- const int x_idx = block & ((1 << bwl) - 1), y_idx = block >> bwl;
- const int x = x_idx * 4, y = y_idx * 4;
+ const int bh = 4 << bhl, bw = 4 << bwl;
+ const int x = 4 * (block & ((1 << bwl) - 1)), y = 4 * (block >> bwl);
const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
int which_mv;
--- a/vp9/common/vp9_reconintra.c
+++ b/vp9/common/vp9_reconintra.c
@@ -362,14 +362,13 @@
void vp9_build_intra_predictors_sby_s(MACROBLOCKD *xd,
BLOCK_SIZE_TYPE bsize) {- const int bwl = b_width_log2(bsize), bw = 4 << bwl;
- const int bhl = b_height_log2(bsize), bh = 4 << bhl;
-
- vp9_build_intra_predictors(xd->plane[0].dst.buf, xd->plane[0].dst.stride,
- xd->plane[0].dst.buf, xd->plane[0].dst.stride,
+ const struct macroblockd_plane* const pd = &xd->plane[0];
+ const int bw = plane_block_width(bsize, pd);
+ const int bh = plane_block_height(bsize, pd);
+ vp9_build_intra_predictors(pd->dst.buf, pd->dst.stride,
+ pd->dst.buf, pd->dst.stride,
xd->mode_info_context->mbmi.mode,
- bw, bh,
- xd->up_available, xd->left_available,
+ bw, bh, xd->up_available, xd->left_available,
0 /*xd->right_available*/);
}
@@ -398,11 +397,9 @@
uint8_t *predictor, int pre_stride) {const int bwl = bwl_in - tx_size;
const int wmask = (1 << bwl) - 1;
- const int have_top =
- (block_idx >> bwl) || xd->up_available;
- const int have_left =
- (block_idx & wmask) || xd->left_available;
- int have_right = ((block_idx & wmask) != wmask);
+ const int have_top = (block_idx >> bwl) || xd->up_available;
+ const int have_left = (block_idx & wmask) || xd->left_available;
+ const int have_right = ((block_idx & wmask) != wmask);
const int txfm_block_size = 4 << tx_size;
assert(bwl >= 0);
--- a/vp9/encoder/vp9_encodemb.c
+++ b/vp9/encoder/vp9_encodemb.c
@@ -41,15 +41,15 @@
static void subtract_plane(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize, int plane) {- const MACROBLOCKD * const xd = &x->e_mbd;
- const int bw = 4 << (b_width_log2(bsize) - xd->plane[plane].subsampling_x);
- const int bh = 4 << (b_height_log2(bsize) - xd->plane[plane].subsampling_y);
- const uint8_t *src = x->plane[plane].src.buf;
- const int src_stride = x->plane[plane].src.stride;
+ struct macroblock_plane *const p = &x->plane[plane];
+ const MACROBLOCKD *const xd = &x->e_mbd;
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int bw = plane_block_width(bsize, pd);
+ const int bh = plane_block_height(bsize, pd);
- vp9_subtract_block(bh, bw,
- x->plane[plane].src_diff, bw, src, src_stride,
- xd->plane[plane].dst.buf, xd->plane[plane].dst.stride);
+ vp9_subtract_block(bh, bw, p->src_diff, bw,
+ p->src.buf, p->src.stride,
+ pd->dst.buf, pd->dst.stride);
}
void vp9_subtract_sby(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {@@ -370,7 +370,7 @@
void vp9_optimize_b(int plane, int block, BLOCK_SIZE_TYPE bsize,
int ss_txfrm_size, VP9_COMMON *cm, MACROBLOCK *mb,
struct optimize_ctx *ctx) {- MACROBLOCKD* const xd = &mb->e_mbd;
+ MACROBLOCKD *const xd = &mb->e_mbd;
int x, y;
// find current entropy context
@@ -377,8 +377,7 @@
txfrm_block_to_raster_xy(xd, bsize, plane, block, ss_txfrm_size, &x, &y);
optimize_b(cm, mb, plane, block, bsize,
- &ctx->ta[plane][x], &ctx->tl[plane][y],
- ss_txfrm_size / 2);
+ &ctx->ta[plane][x], &ctx->tl[plane][y], ss_txfrm_size / 2);
}
static void optimize_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
@@ -417,13 +416,11 @@
}
}
-void vp9_optimize_sby(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {+void vp9_optimize_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {struct optimize_ctx ctx;
struct optimize_block_args arg = {cm, x, &ctx};vp9_optimize_init(&x->e_mbd, bsize, &ctx);
- foreach_transformed_block_in_plane(&x->e_mbd, bsize, 0,
- optimize_block, &arg);
+ foreach_transformed_block_in_plane(&x->e_mbd, bsize, 0, optimize_block, &arg);
}
void vp9_optimize_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
@@ -445,10 +442,11 @@
struct encode_b_args* const args = arg;
MACROBLOCK* const x = args->x;
MACROBLOCKD* const xd = &x->e_mbd;
- const int bw = 4 << (b_width_log2(bsize) - xd->plane[plane].subsampling_x);
+ const int bw = plane_block_width(bsize, &xd->plane[plane]);
const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
block, ss_txfrm_size);
- int16_t* const src_diff = raster_block_offset_int16(xd, bsize, plane,
+ int16_t *const coeff = BLOCK_OFFSET(x->plane[plane].coeff, block, 16);
+ int16_t *const src_diff = raster_block_offset_int16(xd, bsize, plane,
raster_block,
x->plane[plane].src_diff);
TX_TYPE tx_type = DCT_DCT;
@@ -455,45 +453,28 @@
switch (ss_txfrm_size / 2) {case TX_32X32:
- vp9_short_fdct32x32(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw * 2);
+ vp9_short_fdct32x32(src_diff, coeff, bw * 2);
break;
case TX_16X16:
tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
- if (tx_type != DCT_DCT) {- vp9_short_fht16x16(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw, tx_type);
- } else {- x->fwd_txm16x16(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw * 2);
- }
+ if (tx_type != DCT_DCT)
+ vp9_short_fht16x16(src_diff, coeff, bw, tx_type);
+ else
+ x->fwd_txm16x16(src_diff, coeff, bw * 2);
break;
case TX_8X8:
tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
- if (tx_type != DCT_DCT) {- vp9_short_fht8x8(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw, tx_type);
- } else {- x->fwd_txm8x8(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw * 2);
- }
+ if (tx_type != DCT_DCT)
+ vp9_short_fht8x8(src_diff, coeff, bw, tx_type);
+ else
+ x->fwd_txm8x8(src_diff, coeff, bw * 2);
break;
case TX_4X4:
tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
- if (tx_type != DCT_DCT) {- vp9_short_fht4x4(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw, tx_type);
- } else {- x->fwd_txm4x4(src_diff,
- BLOCK_OFFSET(x->plane[plane].coeff, block, 16),
- bw * 2);
- }
+ if (tx_type != DCT_DCT)
+ vp9_short_fht4x4(src_diff, coeff, bw, tx_type);
+ else
+ x->fwd_txm4x4(src_diff, coeff, bw * 2);
break;
default:
assert(0);
@@ -504,15 +485,16 @@
static void encode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
int ss_txfrm_size, void *arg) {- struct encode_b_args* const args = arg;
- MACROBLOCK* const x = args->x;
- MACROBLOCKD* const xd = &x->e_mbd;
+ struct encode_b_args *const args = arg;
+ MACROBLOCK *const x = args->x;
+ MACROBLOCKD *const xd = &x->e_mbd;
const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
block, ss_txfrm_size);
- uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ int16_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block, 16);
+ uint8_t *const dst = raster_block_offset_uint8(xd, bsize, plane,
raster_block,
- xd->plane[plane].dst.buf,
- xd->plane[plane].dst.stride);
+ pd->dst.buf, pd->dst.stride);
TX_TYPE tx_type = DCT_DCT;
xform_quant(plane, block, bsize, ss_txfrm_size, arg);
@@ -522,50 +504,37 @@
switch (ss_txfrm_size / 2) {case TX_32X32:
- vp9_short_idct32x32_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
+ vp9_short_idct32x32_add(dqcoeff, dst, pd->dst.stride);
break;
case TX_16X16:
tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {- vp9_short_idct16x16_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
- } else {- vp9_short_iht16x16_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride,
- tx_type);
- }
+ if (tx_type == DCT_DCT)
+ vp9_short_idct16x16_add(dqcoeff, dst, pd->dst.stride);
+ else
+ vp9_short_iht16x16_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
case TX_8X8:
tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {- vp9_short_idct8x8_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
- } else {- vp9_short_iht8x8_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride,
- tx_type);
- }
+ if (tx_type == DCT_DCT)
+ vp9_short_idct8x8_add(dqcoeff, dst, pd->dst.stride);
+ else
+ vp9_short_iht8x8_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
case TX_4X4:
tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {+ if (tx_type == DCT_DCT)
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
- vp9_inverse_transform_b_4x4_add(xd, xd->plane[plane].eobs[block],
- BLOCK_OFFSET(xd->plane[plane].dqcoeff, block, 16), dst,
- xd->plane[plane].dst.stride);
- } else {- vp9_short_iht4x4_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff, block, 16),
- dst, xd->plane[plane].dst.stride, tx_type);
- }
+ vp9_inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
+ dst, pd->dst.stride);
+ else
+ vp9_short_iht4x4_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
}
}
-void vp9_xform_quant_sby(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {+void vp9_xform_quant_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {MACROBLOCKD* const xd = &x->e_mbd;
struct encode_b_args arg = {cm, x, NULL};@@ -572,8 +541,8 @@
foreach_transformed_block_in_plane(xd, bsize, 0, xform_quant, &arg);
}
-void vp9_xform_quant_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {+void vp9_xform_quant_sbuv(VP9_COMMON *cm, MACROBLOCK *x,
+ BLOCK_SIZE_TYPE bsize) {MACROBLOCKD* const xd = &x->e_mbd;
struct encode_b_args arg = {cm, x, NULL};@@ -580,9 +549,8 @@
foreach_transformed_block_uv(xd, bsize, xform_quant, &arg);
}
-void vp9_encode_sby(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {- MACROBLOCKD* const xd = &x->e_mbd;
+void vp9_encode_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {+ MACROBLOCKD *const xd = &x->e_mbd;
struct optimize_ctx ctx;
struct encode_b_args arg = {cm, x, &ctx};@@ -593,9 +561,8 @@
foreach_transformed_block_in_plane(xd, bsize, 0, encode_block, &arg);
}
-void vp9_encode_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {- MACROBLOCKD* const xd = &x->e_mbd;
+void vp9_encode_sbuv(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {+ MACROBLOCKD *const xd = &x->e_mbd;
struct optimize_ctx ctx;
struct encode_b_args arg = {cm, x, &ctx};@@ -606,9 +573,8 @@
foreach_transformed_block_uv(xd, bsize, encode_block, &arg);
}
-void vp9_encode_sb(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize) {- MACROBLOCKD* const xd = &x->e_mbd;
+void vp9_encode_sb(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {+ MACROBLOCKD *const xd = &x->e_mbd;
struct optimize_ctx ctx;
struct encode_b_args arg = {cm, x, &ctx};@@ -622,25 +588,25 @@
static void encode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
int ss_txfrm_size, void *arg) {struct encode_b_args* const args = arg;
- MACROBLOCK* const x = args->x;
- MACROBLOCKD* const xd = &x->e_mbd;
- MB_MODE_INFO* const mbmi = &xd->mode_info_context->mbmi;
+ MACROBLOCK *const x = args->x;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
- const int bw = 4 << (b_width_log2(bsize) - xd->plane[plane].subsampling_x);
+ struct macroblock_plane *const p = &x->plane[plane];
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ int16_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block, 16);
+ const int bw = plane_block_width(bsize, pd);
const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
block, ss_txfrm_size);
- uint8_t* const src =
- raster_block_offset_uint8(xd, bsize, plane, raster_block,
- x->plane[plane].src.buf,
- x->plane[plane].src.stride);
- uint8_t* const dst =
- raster_block_offset_uint8(xd, bsize, plane, raster_block,
- xd->plane[plane].dst.buf,
- xd->plane[plane].dst.stride);
- int16_t* const src_diff =
- raster_block_offset_int16(xd, bsize, plane,
- raster_block, x->plane[plane].src_diff);
+ uint8_t *const src = raster_block_offset_uint8(xd, bsize, plane, raster_block,
+ p->src.buf, p->src.stride);
+ uint8_t *const dst = raster_block_offset_uint8(xd, bsize, plane, raster_block,
+ pd->dst.buf, pd->dst.stride);
+ int16_t *const src_diff = raster_block_offset_int16(xd, bsize, plane,
+ raster_block,
+ p->src_diff);
+
const int txfm_b_size = 4 << tx_size;
int ib = raster_block;
int tx_ib = ib >> tx_size;
@@ -650,7 +616,8 @@
int mode, b_mode;
mode = plane == 0? mbmi->mode: mbmi->uv_mode;
- if (mbmi->sb_type < BLOCK_SIZE_SB8X8 && plane == 0 &&
+ if (plane == 0 &&
+ mbmi->sb_type < BLOCK_SIZE_SB8X8 &&
mbmi->ref_frame == INTRA_FRAME)
b_mode = xd->mode_info_context->bmi[ib].as_mode.first;
else
@@ -658,65 +625,52 @@
assert(b_mode >= DC_PRED && b_mode <= TM_PRED);
- plane_b_size = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
+ plane_b_size = b_width_log2(bsize) - pd->subsampling_x;
vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size, b_mode,
- dst, xd->plane[plane].dst.stride);
- vp9_subtract_block(txfm_b_size, txfm_b_size,
- src_diff, bw,
- src, x->plane[plane].src.stride,
- dst, xd->plane[plane].dst.stride);
+ dst, pd->dst.stride);
+ vp9_subtract_block(txfm_b_size, txfm_b_size, src_diff, bw,
+ src, p->src.stride, dst, pd->dst.stride);
xform_quant(plane, block, bsize, ss_txfrm_size, arg);
- /*
- if (x->optimize)
- vp9_optimize_b(plane, block, bsize, ss_txfrm_size, args->cm, x, args->ctx);
- */
+
+ // if (x->optimize)
+ // vp9_optimize_b(plane, block, bsize, ss_txfrm_size,
+ // args->cm, x, args->ctx);
+
switch (ss_txfrm_size / 2) {case TX_32X32:
- vp9_short_idct32x32_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
+ vp9_short_idct32x32_add(dqcoeff, dst, pd->dst.stride);
break;
case TX_16X16:
tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {- vp9_short_idct16x16_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
- } else {- vp9_short_iht16x16_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride,
- tx_type);
- }
+ if (tx_type == DCT_DCT)
+ vp9_short_idct16x16_add(dqcoeff, dst, pd->dst.stride);
+ else
+ vp9_short_iht16x16_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
case TX_8X8:
tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {- vp9_short_idct8x8_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride);
- } else {- vp9_short_iht8x8_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff,
- block, 16), dst, xd->plane[plane].dst.stride,
- tx_type);
- }
+ if (tx_type == DCT_DCT)
+ vp9_short_idct8x8_add(dqcoeff, dst, pd->dst.stride);
+ else
+ vp9_short_iht8x8_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
case TX_4X4:
tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
- if (tx_type == DCT_DCT) {+ if (tx_type == DCT_DCT)
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
- vp9_inverse_transform_b_4x4_add(xd, xd->plane[plane].eobs[block],
- BLOCK_OFFSET(xd->plane[plane].dqcoeff, block, 16), dst,
- xd->plane[plane].dst.stride);
- } else {- vp9_short_iht4x4_add(BLOCK_OFFSET(xd->plane[plane].dqcoeff, block, 16),
- dst, xd->plane[plane].dst.stride, tx_type);
- }
+ vp9_inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
+ dst, pd->dst.stride);
+ else
+ vp9_short_iht4x4_add(dqcoeff, dst, pd->dst.stride, tx_type);
break;
}
}
-void vp9_encode_intra_block_y(VP9_COMMON *const cm, MACROBLOCK *x,
+void vp9_encode_intra_block_y(VP9_COMMON *cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {MACROBLOCKD* const xd = &x->e_mbd;
struct optimize_ctx ctx;
@@ -725,7 +679,7 @@
foreach_transformed_block_in_plane(xd, bsize, 0,
encode_block_intra, &arg);
}
-void vp9_encode_intra_block_uv(VP9_COMMON *const cm, MACROBLOCK *x,
+void vp9_encode_intra_block_uv(VP9_COMMON *cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {MACROBLOCKD* const xd = &x->e_mbd;
struct optimize_ctx ctx;
--- a/vp9/encoder/vp9_encodemb.h
+++ b/vp9/encoder/vp9_encodemb.h
@@ -26,25 +26,21 @@
ENTROPY_CONTEXT ta[MAX_MB_PLANE][16];
ENTROPY_CONTEXT tl[MAX_MB_PLANE][16];
};
+
void vp9_optimize_init(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
struct optimize_ctx *ctx);
void vp9_optimize_b(int plane, int block, BLOCK_SIZE_TYPE bsize,
int ss_txfrm_size, VP9_COMMON *cm, MACROBLOCK *x,
struct optimize_ctx *ctx);
-void vp9_optimize_sby(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize);
-void vp9_optimize_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize);
+void vp9_optimize_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
+void vp9_optimize_sbuv(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
-void vp9_encode_sb(VP9_COMMON *const cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
-void vp9_encode_sby(VP9_COMMON *const cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
-void vp9_encode_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize);
+void vp9_encode_sb(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
+void vp9_encode_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
+void vp9_encode_sbuv(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
-void vp9_xform_quant_sby(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize);
-void vp9_xform_quant_sbuv(VP9_COMMON *const cm, MACROBLOCK *x,
- BLOCK_SIZE_TYPE bsize);
+void vp9_xform_quant_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
+void vp9_xform_quant_sbuv(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
void vp9_subtract_block(int rows, int cols,
int16_t *diff_ptr, int diff_stride,
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -1854,9 +1854,8 @@
static enum BlockSize get_plane_block_size(BLOCK_SIZE_TYPE bsize,
struct macroblockd_plane *pd) {- const int bwl = b_width_log2(bsize) - pd->subsampling_x;
- const int bhl = b_height_log2(bsize) - pd->subsampling_y;
- return get_block_size(4 << bwl, 4 << bhl);
+ return get_block_size(plane_block_width(bsize, pd),
+ plane_block_height(bsize, pd));
}
static void model_rd_for_sb(VP9_COMP *cpi, BLOCK_SIZE_TYPE bsize,
@@ -1873,14 +1872,13 @@
struct macroblockd_plane *const pd = &xd->plane[i];
// TODO(dkovalev) the same code in get_plane_block_size
- const int bwl = b_width_log2(bsize) - pd->subsampling_x;
- const int bhl = b_height_log2(bsize) - pd->subsampling_y;
- const enum BlockSize bs = get_block_size(4 << bwl, 4 << bhl);
+ const int bw = plane_block_width(bsize, pd);
+ const int bh = plane_block_height(bsize, pd);
+ const enum BlockSize bs = get_block_size(bw, bh);
int rate, dist;
var = cpi->fn_ptr[bs].vf(p->src.buf, p->src.stride,
pd->dst.buf, pd->dst.stride, &sse);
- model_rd_from_var_lapndz(var, 16 << (bwl + bhl),
- pd->dequant[1] >> 3, &rate, &dist);
+ model_rd_from_var_lapndz(var, bw * bh, pd->dequant[1] >> 3, &rate, &dist);
rate_sum += rate;
dist_sum += dist;