}
static BLOCK_SIZE_TYPE get_plane_block_size(BLOCK_SIZE_TYPE bsize,
- struct macroblockd_plane *pd) {
+ const struct macroblockd_plane *pd) {
BLOCK_SIZE_TYPE bs = ss_size_lookup[bsize]
[pd->subsampling_x][pd->subsampling_y];
assert(bs < BLOCK_SIZES);
static INLINE void foreach_transformed_block_in_plane(
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize, int plane,
foreach_transformed_block_visitor visit, void *arg) {
- const int bw = b_width_log2(bsize), bh = b_height_log2(bsize);
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
// block and transform sizes, in number of 4x4 blocks log 2 ("*_b")
// 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
const MB_MODE_INFO* mbmi = &xd->mode_info_context->mbmi;
const TX_SIZE tx_size = plane ? get_uv_tx_size(mbmi)
: mbmi->txfm_size;
- const int block_size_b = bw + bh;
+ const int bw = b_width_log2(bsize) - pd->subsampling_x;
+ const int bh = b_height_log2(bsize) - pd->subsampling_y;
const int txfrm_size_b = tx_size * 2;
-
- // subsampled size of the block
- const int ss_sum = xd->plane[plane].subsampling_x
- + xd->plane[plane].subsampling_y;
- const int ss_block_size = block_size_b - ss_sum;
-
const int step = 1 << txfrm_size_b;
-
int i;
- assert(txfrm_size_b <= block_size_b);
- assert(txfrm_size_b <= ss_block_size);
-
// If mb_to_right_edge is < 0 we are in a situation in which
// the current block size extends into the UMV and we won't
// visit the sub blocks that are wholly within the UMV.
if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0) {
int r, c;
- const int sw = bw - xd->plane[plane].subsampling_x;
- const int sh = bh - xd->plane[plane].subsampling_y;
- int max_blocks_wide = 1 << sw;
- int max_blocks_high = 1 << sh;
+
+ int max_blocks_wide = 1 << bw;
+ int max_blocks_high = 1 << bh;
// xd->mb_to_right_edge is in units of pixels * 8. This converts
// it to 4x4 block sizes.
if (xd->mb_to_right_edge < 0)
- max_blocks_wide +=
- (xd->mb_to_right_edge >> (5 + xd->plane[plane].subsampling_x));
+ max_blocks_wide += (xd->mb_to_right_edge >> (5 + pd->subsampling_x));
if (xd->mb_to_bottom_edge < 0)
- max_blocks_high +=
- (xd->mb_to_bottom_edge >> (5 + xd->plane[plane].subsampling_y));
+ max_blocks_high += (xd->mb_to_bottom_edge >> (5 + pd->subsampling_y));
i = 0;
// Unlike the normal case - in here we have to keep track of the
// row and column of the blocks we use so that we know if we are in
// the unrestricted motion border.
- for (r = 0; r < (1 << sh); r += (1 << tx_size)) {
- for (c = 0; c < (1 << sw); c += (1 << tx_size)) {
+ for (r = 0; r < (1 << bh); r += (1 << tx_size)) {
+ for (c = 0; c < (1 << bw); c += (1 << tx_size)) {
if (r < max_blocks_high && c < max_blocks_wide)
visit(plane, i, bsize, txfrm_size_b, arg);
i += step;
}
}
} else {
- for (i = 0; i < (1 << ss_block_size); i += step) {
+ const int ss_block_size = bw + bh;
+ assert(txfrm_size_b <= ss_block_size);
+ for (i = 0; i < (1 << ss_block_size); i += step)
visit(plane, i, bsize, txfrm_size_b, arg);
- }
}
}
foreach_transformed_block_visitor visit, void *arg) {
int plane;
- for (plane = 0; plane < MAX_MB_PLANE; plane++) {
- foreach_transformed_block_in_plane(xd, bsize, plane,
- visit, arg);
- }
+ for (plane = 0; plane < MAX_MB_PLANE; plane++)
+ foreach_transformed_block_in_plane(xd, bsize, plane, visit, arg);
}
static INLINE void foreach_transformed_block_uv(
foreach_transformed_block_visitor visit, void *arg) {
int plane;
- for (plane = 1; plane < MAX_MB_PLANE; plane++) {
- foreach_transformed_block_in_plane(xd, bsize, plane,
- visit, arg);
- }
+ for (plane = 1; plane < MAX_MB_PLANE; plane++)
+ foreach_transformed_block_in_plane(xd, bsize, plane, visit, arg);
}
// TODO(jkoleszar): In principle, pred_w, pred_h are unnecessary, as we could
foreach_predicted_block_visitor visit, void *arg) {
int plane;
- for (plane = 0; plane < MAX_MB_PLANE; plane++) {
+ for (plane = 0; plane < MAX_MB_PLANE; plane++)
foreach_predicted_block_in_plane(xd, bsize, plane, visit, arg);
- }
}
static int raster_block_offset(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
int plane, int block,
int ss_txfrm_size) {
const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
- const int txwl = ss_txfrm_size / 2;
+ const int txwl = ss_txfrm_size >> 1;
const int tx_cols_log2 = bwl - txwl;
const int tx_cols = 1 << tx_cols_log2;
const int raster_mb = block >> ss_txfrm_size;
int ss_txfrm_size,
int *x, int *y) {
const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
- const int txwl = ss_txfrm_size / 2;
+ const int txwl = ss_txfrm_size >> 1;
const int tx_cols_log2 = bwl - txwl;
const int tx_cols = 1 << tx_cols_log2;
const int raster_mb = block >> ss_txfrm_size;
if (xd->mb_to_right_edge < 0)
mi_blocks_wide += (xd->mb_to_right_edge >> (5 + pd->subsampling_x));
+ if (xd->mb_to_bottom_edge < 0)
+ mi_blocks_high += (xd->mb_to_bottom_edge >> (5 + pd->subsampling_y));
+
// this code attempts to avoid copying into contexts that are outside
// our border. Any blocks that do are set to 0...
if (above_contexts + aoff > mi_blocks_wide)
above_contexts = mi_blocks_wide - aoff;
- if (xd->mb_to_bottom_edge < 0)
- mi_blocks_high += (xd->mb_to_bottom_edge >> (5 + pd->subsampling_y));
-
if (left_contexts + loff > mi_blocks_high)
left_contexts = mi_blocks_high - loff;
MACROBLOCKD *xd = &arg->pbi->mb;
struct macroblockd_plane* pd = &xd->plane[plane];
const int segment_id = xd->mode_info_context->mbmi.segment_id;
- const TX_SIZE ss_tx_size = ss_txfrm_size / 2;
+ const TX_SIZE tx_size = ss_txfrm_size >> 1;
const int seg_eob = get_eob(&xd->seg, segment_id, 16 << ss_txfrm_size);
const int off = block >> ss_txfrm_size;
- const int mod = bw - ss_tx_size - pd->subsampling_x;
- const int aoff = (off & ((1 << mod) - 1)) << ss_tx_size;
- const int loff = (off >> mod) << ss_tx_size;
- const int tx_size_in_blocks = 1 << ss_tx_size;
+ const int mod = bw - tx_size - pd->subsampling_x;
+ const int aoff = (off & ((1 << mod) - 1)) << tx_size;
+ const int loff = (off >> mod) << tx_size;
+ const int tx_size_in_blocks = 1 << tx_size;
ENTROPY_CONTEXT *A = pd->above_context + aoff;
ENTROPY_CONTEXT *L = pd->left_context + loff;
const int eob = decode_coefs(&arg->pbi->common, xd, arg->r, block,
pd->plane_type, seg_eob,
BLOCK_OFFSET(pd->qcoeff, block),
- ss_tx_size, pd->dequant, A, L);
+ tx_size, pd->dequant, A, L);
if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0) {
set_contexts_on_border(xd, bsize, plane, tx_size_in_blocks, eob, aoff, loff,
int ss_txfrm_size, MACROBLOCK *mb,
struct optimize_ctx *ctx) {
MACROBLOCKD *const xd = &mb->e_mbd;
+ const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size >> 1);
int x, y;
// find current entropy context
txfrm_block_to_raster_xy(xd, bsize, plane, block, ss_txfrm_size, &x, &y);
- optimize_b(mb, plane, block, bsize,
- &ctx->ta[plane][x], &ctx->tl[plane][y], ss_txfrm_size / 2);
+ optimize_b(mb, plane, block, bsize, &ctx->ta[plane][x], &ctx->tl[plane][y],
+ tx_size);
}
static void optimize_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
int16_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
const int16_t *scan, *iscan;
uint16_t *eob = &pd->eobs[block];
- const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
+ const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size >> 1);
const int bwl = b_width_log2(bsize) - pd->subsampling_x, bw = 1 << bwl;
const int twl = bwl - tx_size, twmask = (1 << twl) - 1;
int xoff, yoff;
uint8_t *const dst = raster_block_offset_uint8(xd, bsize, plane,
raster_block,
pd->dst.buf, pd->dst.stride);
+ const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size >> 1);
+
xform_quant(plane, block, bsize, ss_txfrm_size, arg);
if (x->optimize)
vp9_optimize_b(plane, block, bsize, ss_txfrm_size, x, args->ctx);
- if (x->skip_encode)
- return;
- if (pd->eobs[block] == 0)
+ if (x->skip_encode || pd->eobs[block] == 0)
return;
- switch (ss_txfrm_size / 2) {
+ switch (tx_size) {
case TX_32X32:
vp9_short_idct32x32_add(dqcoeff, dst, pd->dst.stride);
break;
inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
dst, pd->dst.stride);
break;
+ default:
+ assert(!"Invalid transform size");
}
}
MACROBLOCK *const x = args->x;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
- const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
+ const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size >> 1);
struct macroblock_plane *const p = &x->plane[plane];
struct macroblockd_plane *const pd = &xd->plane[plane];
int16_t *coeff = BLOCK_OFFSET(p->coeff, block);
projects / libvpx / commitdiff