diff options
Diffstat (limited to 'vp9/encoder')
-rw-r--r-- | vp9/encoder/vp9_bitstream.c | 83 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodeframe.c | 503 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodemb.c | 8 | ||||
-rw-r--r-- | vp9/encoder/vp9_firstpass.c | 9 | ||||
-rw-r--r-- | vp9/encoder/vp9_mbgraph.c | 14 | ||||
-rw-r--r-- | vp9/encoder/vp9_onyx_if.c | 39 | ||||
-rw-r--r-- | vp9/encoder/vp9_ratectrl.c | 4 | ||||
-rw-r--r-- | vp9/encoder/vp9_rdopt.c | 88 | ||||
-rw-r--r-- | vp9/encoder/vp9_rdopt.h | 4 | ||||
-rw-r--r-- | vp9/encoder/vp9_segmentation.c | 101 |
10 files changed, 488 insertions, 365 deletions
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c index 870d9d41b..d099960f4 100644 --- a/vp9/encoder/vp9_bitstream.c +++ b/vp9/encoder/vp9_bitstream.c @@ -686,8 +686,7 @@ static void update_ref_probs(VP9_COMP *const cpi) { } static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, - vp9_writer *bc, - int mb_rows_left, int mb_cols_left) { + vp9_writer *bc, int mi_row, int mi_col) { VP9_COMMON *const pc = &cpi->common; const nmv_context *nmvc = &pc->fc.nmvc; MACROBLOCK *const x = &cpi->mb; @@ -697,21 +696,11 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, const MV_REFERENCE_FRAME rf = mi->ref_frame; const MB_PREDICTION_MODE mode = mi->mode; const int segment_id = mi->segment_id; - const int bw = 1 << mb_width_log2(mi->sb_type); - const int bh = 1 << mb_height_log2(mi->sb_type); int skip_coeff; - int mb_row = pc->mb_rows - mb_rows_left; - int mb_col = pc->mb_cols - mb_cols_left; xd->prev_mode_info_context = pc->prev_mi + (m - pc->mi); x->partition_info = x->pi + (m - pc->mi); - // Distance of Mb to the various image edges. - // These specified to 8th pel as they are always compared to MV - // values that are in 1/8th pel units - - set_mb_row_col(pc, xd, mb_row, bh, mb_col, bw); - #ifdef ENTROPY_STATS active_section = 9; #endif @@ -926,8 +915,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, static void write_mb_modes_kf(const VP9_COMP *cpi, MODE_INFO *m, - vp9_writer *bc, - int mb_rows_left, int mb_cols_left) { + vp9_writer *bc, int mi_row, int mi_col) { const VP9_COMMON *const c = &cpi->common; const MACROBLOCKD *const xd = &cpi->mb.e_mbd; const int mis = c->mode_info_stride; @@ -1145,23 +1133,21 @@ void print_zpcstats() { static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, TOKENEXTRA **tok, TOKENEXTRA *tok_end, - int mb_row, int mb_col) { + int mi_row, int mi_col) { VP9_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->mb.e_mbd; xd->mode_info_context = m; - set_mb_row_col(&cpi->common, xd, mb_row, - 1 << mb_height_log2(m->mbmi.sb_type), - mb_col, 1 << mb_width_log2(m->mbmi.sb_type)); + set_mi_row_col(&cpi->common, xd, mi_row, + 1 << mi_height_log2(m->mbmi.sb_type), + mi_col, 1 << mi_width_log2(m->mbmi.sb_type)); if (cm->frame_type == KEY_FRAME) { - write_mb_modes_kf(cpi, m, bc, - cm->mb_rows - mb_row, cm->mb_cols - mb_col); + write_mb_modes_kf(cpi, m, bc, mi_row, mi_col); #ifdef ENTROPY_STATS active_section = 8; #endif } else { - pack_inter_mode_mvs(cpi, m, bc, - cm->mb_rows - mb_row, cm->mb_cols - mb_col); + pack_inter_mode_mvs(cpi, m, bc, mi_row, mi_col); #ifdef ENTROPY_STATS active_section = 1; #endif @@ -1173,23 +1159,23 @@ static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, TOKENEXTRA **tok, TOKENEXTRA *tok_end, - int mb_row, int mb_col, + int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) { VP9_COMMON *const cm = &cpi->common; MACROBLOCKD *xd = &cpi->mb.e_mbd; const int mis = cm->mode_info_stride; int bwl, bhl; int bw, bh; - int bsl = mb_width_log2(bsize), bs = (1 << bsl) / 2; + int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2; int n; PARTITION_TYPE partition; BLOCK_SIZE_TYPE subsize; - if (mb_row >= cm->mb_rows || mb_col >= cm->mb_cols) + if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; - bwl = mb_width_log2(m->mbmi.sb_type); - bhl = mb_height_log2(m->mbmi.sb_type); + bwl = mi_width_log2(m->mbmi.sb_type); + bhl = mi_height_log2(m->mbmi.sb_type); bw = 1 << bwl; bh = 1 << bhl; @@ -1207,8 +1193,9 @@ static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, if (bsize > BLOCK_SIZE_MB16X16) { int pl; - xd->left_seg_context = cm->left_seg_context + (mb_row & 3); - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->left_seg_context = + cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3); + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, bsize); // encode the partition information write_token(bc, vp9_partition_tree, cm->fc.partition_prob[pl], @@ -1218,21 +1205,21 @@ static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, switch (partition) { case PARTITION_NONE: subsize = bsize; - write_modes_b(cpi, m, bc, tok, tok_end, mb_row, mb_col); + write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col); break; case PARTITION_HORZ: subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB64X32 : BLOCK_SIZE_SB32X16; - write_modes_b(cpi, m, bc, tok, tok_end, mb_row, mb_col); - if ((mb_row + bh) < cm->mb_rows) - write_modes_b(cpi, m + bh * mis, bc, tok, tok_end, mb_row + bh, mb_col); + write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col); + if ((mi_row + bh) < cm->mi_rows) + write_modes_b(cpi, m + bh * mis, bc, tok, tok_end, mi_row + bh, mi_col); break; case PARTITION_VERT: subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X64 : BLOCK_SIZE_SB16X32; - write_modes_b(cpi, m, bc, tok, tok_end, mb_row, mb_col); - if ((mb_col + bw) < cm->mb_cols) - write_modes_b(cpi, m + bw, bc, tok, tok_end, mb_row, mb_col + bw); + write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col); + if ((mi_col + bw) < cm->mi_cols) + write_modes_b(cpi, m + bw, bc, tok, tok_end, mi_row, mi_col + bw); break; case PARTITION_SPLIT: // TODO(jingning): support recursive partitioning down to 16x16 as for @@ -1246,7 +1233,7 @@ static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, for (n = 0; n < 4; n++) { int j = n >> 1, i = n & 0x01; write_modes_sb(cpi, m + j * bs * mis + i * bs, bc, tok, tok_end, - mb_row + j * bs, mb_col + i * bs, subsize); + mi_row + j * bs, mi_col + i * bs, subsize); } break; default: @@ -1257,8 +1244,8 @@ static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32)) return; - xd->left_seg_context = cm->left_seg_context + (mb_row & 3); - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->left_seg_context = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3); + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); update_partition_context(xd, subsize, bsize); } @@ -1267,19 +1254,21 @@ static void write_modes(VP9_COMP *cpi, vp9_writer* const bc, VP9_COMMON *const c = &cpi->common; const int mis = c->mode_info_stride; MODE_INFO *m, *m_ptr = c->mi; - int mb_row, mb_col; + int mi_row, mi_col; - m_ptr += c->cur_tile_mb_col_start + c->cur_tile_mb_row_start * mis; + m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis; vpx_memset(c->above_seg_context, 0, sizeof(PARTITION_CONTEXT) * - mb_cols_aligned_to_sb(c)); + mb_cols_aligned_to_sb(c)); - for (mb_row = c->cur_tile_mb_row_start; - mb_row < c->cur_tile_mb_row_end; mb_row += 4, m_ptr += 4 * mis) { + for (mi_row = c->cur_tile_mi_row_start; + mi_row < c->cur_tile_mi_row_end; + mi_row += (4 << CONFIG_SB8X8), m_ptr += (4 << CONFIG_SB8X8) * mis) { m = m_ptr; vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context)); - for (mb_col = c->cur_tile_mb_col_start; - mb_col < c->cur_tile_mb_col_end; mb_col += 4, m += 4) - write_modes_sb(cpi, m, bc, tok, tok_end, mb_row, mb_col, + for (mi_col = c->cur_tile_mi_col_start; + mi_col < c->cur_tile_mi_col_end; + mi_col += (4 << CONFIG_SB8X8), m += (4 << CONFIG_SB8X8)) + write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col, BLOCK_SIZE_SB64X64); } } diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c index 143656681..8e524f4ba 100644 --- a/vp9/encoder/vp9_encodeframe.c +++ b/vp9/encoder/vp9_encodeframe.c @@ -48,10 +48,10 @@ int enc_debug = 0; void vp9_select_interp_filter_type(VP9_COMP *cpi); static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t, - int output_enabled, int mb_row, int mb_col); + int output_enabled, int mi_row, int mi_col); static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, - int output_enabled, int mb_row, int mb_col, + int output_enabled, int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize); static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x); @@ -358,7 +358,7 @@ static void update_state(VP9_COMP *cpi, int mb_mode = mi->mbmi.mode; int mb_mode_index = ctx->best_mode_index; const int mis = cpi->common.mode_info_stride; - const int bh = 1 << mb_height_log2(bsize), bw = 1 << mb_width_log2(bsize); + const int bh = 1 << mi_height_log2(bsize), bw = 1 << mi_width_log2(bsize); #if CONFIG_DEBUG assert(mb_mode < MB_MODE_COUNT); @@ -371,8 +371,8 @@ static void update_state(VP9_COMP *cpi, // when the mode was picked for it for (y = 0; y < bh; y++) { for (x_idx = 0; x_idx < bw; x_idx++) { - if ((xd->mb_to_right_edge >> 7) + bw > x_idx && - (xd->mb_to_bottom_edge >> 7) + bh > y) { + if ((xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE)) + bw > x_idx && + (xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE)) + bh > y) { MODE_INFO *mi_addr = xd->mode_info_context + x_idx + y * mis; vpx_memcpy(mi_addr, mi, sizeof(MODE_INFO)); @@ -389,6 +389,17 @@ static void update_state(VP9_COMP *cpi, mbmi->mv[0].as_int = x->partition_info->bmi[15].mv.as_int; mbmi->mv[1].as_int = x->partition_info->bmi[15].second_mv.as_int; +#if CONFIG_SB8X8 + vpx_memcpy(x->partition_info + mis, &ctx->partition_info, + sizeof(PARTITION_INFO)); + vpx_memcpy(x->partition_info + 1, &ctx->partition_info, + sizeof(PARTITION_INFO)); + vpx_memcpy(x->partition_info + mis + 1, &ctx->partition_info, + sizeof(PARTITION_INFO)); + xd->mode_info_context[1].mbmi = + xd->mode_info_context[mis].mbmi = + xd->mode_info_context[1 + mis].mbmi = *mbmi; +#endif } x->skip = ctx->skip; @@ -480,6 +491,11 @@ static void update_state(VP9_COMP *cpi, mbmi->best_mv.as_int = best_mv.as_int; mbmi->best_second_mv.as_int = best_second_mv.as_int; vp9_update_nmv_count(cpi, x, &best_mv, &best_second_mv); +#if CONFIG_SB8X8 + xd->mode_info_context[1].mbmi = + xd->mode_info_context[mis].mbmi = + xd->mode_info_context[1 + mis].mbmi = *mbmi; +#endif } #if CONFIG_COMP_INTERINTRA_PRED if (mbmi->mode >= NEARESTMV && mbmi->mode < SPLITMV && @@ -510,7 +526,7 @@ static void update_state(VP9_COMP *cpi, static unsigned find_seg_id(uint8_t *buf, BLOCK_SIZE_TYPE bsize, int start_y, int height, int start_x, int width) { - const int bw = 1 << mb_width_log2(bsize), bh = 1 << mb_height_log2(bsize); + const int bw = 1 << mi_width_log2(bsize), bh = 1 << mi_height_log2(bsize); const int end_x = MIN(start_x + bw, width); const int end_y = MIN(start_y + bh, height); int x, y; @@ -547,15 +563,17 @@ void vp9_setup_src_planes(MACROBLOCK *x, } static void set_offsets(VP9_COMP *cpi, - int mb_row, int mb_col, BLOCK_SIZE_TYPE bsize) { + int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) { MACROBLOCK *const x = &cpi->mb; VP9_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &x->e_mbd; MB_MODE_INFO *mbmi; const int dst_fb_idx = cm->new_fb_idx; + const int idx_str = xd->mode_info_stride * mi_row + mi_col; + const int bw = 1 << mi_width_log2(bsize), bh = 1 << mi_height_log2(bsize); + const int mb_row = mi_row >> CONFIG_SB8X8; + const int mb_col = mi_col >> CONFIG_SB8X8; const int idx_map = mb_row * cm->mb_cols + mb_col; - const int idx_str = xd->mode_info_stride * mb_row + mb_col; - const int bw = 1 << mb_width_log2(bsize), bh = 1 << mb_height_log2(bsize); // entropy context structures xd->above_context = cm->above_context + mb_col; @@ -576,23 +594,23 @@ static void set_offsets(VP9_COMP *cpi, xd->prev_mode_info_context = cm->prev_mi + idx_str; // Set up destination pointers - setup_dst_planes(xd, &cm->yv12_fb[dst_fb_idx], mb_row, mb_col); + setup_dst_planes(xd, &cm->yv12_fb[dst_fb_idx], mi_row, mi_col); /* Set up limit values for MV components to prevent them from * extending beyond the UMV borders assuming 16x16 block size */ - x->mv_row_min = -((mb_row * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND); - x->mv_col_min = -((mb_col * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND); - x->mv_row_max = ((cm->mb_rows - mb_row) * 16 + - (VP9BORDERINPIXELS - 16 * bh - VP9_INTERP_EXTEND)); - x->mv_col_max = ((cm->mb_cols - mb_col) * 16 + - (VP9BORDERINPIXELS - 16 * bw - VP9_INTERP_EXTEND)); + x->mv_row_min = -((mi_row * MI_SIZE) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND); + x->mv_col_min = -((mi_col * MI_SIZE) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND); + x->mv_row_max = ((cm->mi_rows - mi_row) * MI_SIZE + + (VP9BORDERINPIXELS - MI_SIZE * bh - VP9_INTERP_EXTEND)); + x->mv_col_max = ((cm->mi_cols - mi_col) * MI_SIZE + + (VP9BORDERINPIXELS - MI_SIZE * bw - VP9_INTERP_EXTEND)); // Set up distance of MB to edge of frame in 1/8th pel units - assert(!(mb_col & (bw - 1)) && !(mb_row & (bh - 1))); - set_mb_row_col(cm, xd, mb_row, bh, mb_col, bw); + assert(!(mi_col & (bw - 1)) && !(mi_row & (bh - 1))); + set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw); /* set up source buffers */ - vp9_setup_src_planes(x, cpi->Source, mb_row, mb_col); + vp9_setup_src_planes(x, cpi->Source, mi_row, mi_col); /* R/D setup */ x->rddiv = cpi->RDDIV; @@ -602,10 +620,10 @@ static void set_offsets(VP9_COMP *cpi, if (xd->segmentation_enabled) { if (xd->update_mb_segmentation_map) { mbmi->segment_id = find_seg_id(cpi->segmentation_map, bsize, - mb_row, cm->mb_rows, mb_col, cm->mb_cols); + mi_row, cm->mi_rows, mi_col, cm->mi_cols); } else { mbmi->segment_id = find_seg_id(cm->last_frame_seg_map, bsize, - mb_row, cm->mb_rows, mb_col, cm->mb_cols); + mi_row, cm->mi_rows, mi_col, cm->mi_cols); } assert(mbmi->segment_id <= (MAX_MB_SEGMENTS-1)); vp9_mb_init_quantizer(cpi, x); @@ -623,8 +641,10 @@ static void set_offsets(VP9_COMP *cpi, const int x = mb_col & ~3; const int p16 = ((mb_row & 1) << 1) + (mb_col & 1); const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1); - const int tile_progress = cm->cur_tile_mb_col_start * cm->mb_rows; - const int mb_cols = cm->cur_tile_mb_col_end - cm->cur_tile_mb_col_start; + const int tile_progress = + cm->cur_tile_mi_col_start * cm->mb_rows >> CONFIG_SB8X8; + const int mb_cols = + (cm->cur_tile_mi_col_end - cm->cur_tile_mi_col_start) >> CONFIG_SB8X8; cpi->seg0_progress = ((y * mb_cols + x * 4 + p32 + p16 + tile_progress) << 16) / cm->MBs; @@ -635,8 +655,8 @@ static void set_offsets(VP9_COMP *cpi, } static int pick_mb_mode(VP9_COMP *cpi, - int mb_row, - int mb_col, + int mi_row, + int mi_col, TOKENEXTRA **tp, int *totalrate, int *totaldist) { @@ -646,7 +666,7 @@ static int pick_mb_mode(VP9_COMP *cpi, int splitmodes_used = 0; MB_MODE_INFO *mbmi; - set_offsets(cpi, mb_row, mb_col, BLOCK_SIZE_MB16X16); + set_offsets(cpi, mi_row, mi_col, BLOCK_SIZE_MB16X16); if (cpi->oxcf.tuning == VP8_TUNE_SSIM) vp9_activity_masking(cpi, x); @@ -663,7 +683,7 @@ static int pick_mb_mode(VP9_COMP *cpi, vpx_memcpy(&x->mb_context[xd->sb_index][xd->mb_index].mic, xd->mode_info_context, sizeof(MODE_INFO)); } else { - vp9_pick_mode_inter_macroblock(cpi, x, mb_row, mb_col, + vp9_pick_mode_inter_macroblock(cpi, x, mi_row, mi_col, totalrate, totaldist); splitmodes_used += (mbmi->mode == SPLITMV); @@ -675,14 +695,14 @@ static int pick_mb_mode(VP9_COMP *cpi, return splitmodes_used; } -static void pick_sb_modes(VP9_COMP *cpi, int mb_row, int mb_col, +static void pick_sb_modes(VP9_COMP *cpi, int mi_row, int mi_col, TOKENEXTRA **tp, int *totalrate, int *totaldist, BLOCK_SIZE_TYPE bsize, PICK_MODE_CONTEXT *ctx) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; - set_offsets(cpi, mb_row, mb_col, bsize); + set_offsets(cpi, mi_row, mi_col, bsize); xd->mode_info_context->mbmi.sb_type = bsize; if (cpi->oxcf.tuning == VP8_TUNE_SSIM) vp9_activity_masking(cpi, x); @@ -692,12 +712,12 @@ static void pick_sb_modes(VP9_COMP *cpi, int mb_row, int mb_col, if (cm->frame_type == KEY_FRAME) { vp9_rd_pick_intra_mode_sb(cpi, x, totalrate, totaldist, bsize, ctx); } else { - vp9_rd_pick_inter_mode_sb(cpi, x, mb_row, mb_col, totalrate, totaldist, + vp9_rd_pick_inter_mode_sb(cpi, x, mi_row, mi_col, totalrate, totaldist, bsize, ctx); } } -static void update_stats(VP9_COMP *cpi, int mb_row, int mb_col) { +static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; @@ -754,8 +774,8 @@ static void update_stats(VP9_COMP *cpi, int mb_row, int mb_col) { } static void encode_sb(VP9_COMP *cpi, - int mb_row, - int mb_col, + int mi_row, + int mi_col, int output_enabled, TOKENEXTRA **tp, BLOCK_SIZE_TYPE is_sb) { VP9_COMMON *const cm = &cpi->common; @@ -764,19 +784,21 @@ static void encode_sb(VP9_COMP *cpi, BLOCK_SIZE_TYPE bsize = BLOCK_SIZE_SB32X32; int pl; - xd->left_seg_context = cm->left_seg_context + (mb_row & 0x03); - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->left_seg_context = + cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 0x03); + xd->above_seg_context = + cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, bsize); if (is_sb == BLOCK_SIZE_SB32X32) { - set_offsets(cpi, mb_row, mb_col, bsize); + set_offsets(cpi, mi_row, mi_col, bsize); update_state(cpi, &x->sb32_context[xd->sb_index], bsize, output_enabled); encode_superblock(cpi, tp, - output_enabled, mb_row, mb_col, bsize); + output_enabled, mi_row, mi_col, bsize); if (output_enabled) { - update_stats(cpi, mb_row, mb_col); + update_stats(cpi, mi_row, mi_col); cpi->partition_count[pl][PARTITION_NONE]++; (*tp)->token = EOSB_TOKEN; @@ -787,14 +809,16 @@ static void encode_sb(VP9_COMP *cpi, if (output_enabled) cpi->partition_count[pl][PARTITION_VERT]++; - for (i = 0; i < 2 && mb_col + i != cm->mb_cols; i++) { - set_offsets(cpi, mb_row, mb_col + i, BLOCK_SIZE_SB16X32); + for (i = 0; i < 2 && mi_col + (i << CONFIG_SB8X8) != cm->mi_cols; i++) { + set_offsets(cpi, mi_row, mi_col + (i << CONFIG_SB8X8), + BLOCK_SIZE_SB16X32); update_state(cpi, &x->sb16x32_context[xd->sb_index][i], BLOCK_SIZE_SB16X32, output_enabled); encode_superblock(cpi, tp, - output_enabled, mb_row, mb_col + i, BLOCK_SIZE_SB16X32); + output_enabled, mi_row, mi_col + (i << CONFIG_SB8X8), + BLOCK_SIZE_SB16X32); if (output_enabled) { - update_stats(cpi, mb_row, mb_col + i); + update_stats(cpi, mi_row, mi_col + i); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -805,14 +829,16 @@ static void encode_sb(VP9_COMP *cpi, if (output_enabled) cpi->partition_count[pl][PARTITION_HORZ]++; - for (i = 0; i < 2 && mb_row + i != cm->mb_rows; i++) { - set_offsets(cpi, mb_row + i, mb_col, BLOCK_SIZE_SB32X16); + for (i = 0; i < 2 && mi_row + (i << CONFIG_SB8X8) != cm->mi_rows; i++) { + set_offsets(cpi, mi_row + (i << CONFIG_SB8X8), mi_col, + BLOCK_SIZE_SB32X16); update_state(cpi, &x->sb32x16_context[xd->sb_index][i], BLOCK_SIZE_SB32X16, output_enabled); encode_superblock(cpi, tp, - output_enabled, mb_row + i, mb_col, BLOCK_SIZE_SB32X16); + output_enabled, mi_row + (i << CONFIG_SB8X8), mi_col, + BLOCK_SIZE_SB32X16); if (output_enabled) { - update_stats(cpi, mb_row + i, mb_col); + update_stats(cpi, mi_row + (i << CONFIG_SB8X8), mi_col); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -824,14 +850,15 @@ static void encode_sb(VP9_COMP *cpi, cpi->partition_count[pl][PARTITION_SPLIT]++; for (i = 0; i < 4; i++) { - const int x_idx = i & 1, y_idx = i >> 1; + const int x_idx = (i & 1) << CONFIG_SB8X8; + const int y_idx = (i >> 1) << CONFIG_SB8X8; - if ((mb_row + y_idx >= cm->mb_rows) || (mb_col + x_idx >= cm->mb_cols)) { + if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols)) { // MB lies outside frame, move on continue; } - set_offsets(cpi, mb_row + y_idx, mb_col + x_idx, BLOCK_SIZE_MB16X16); + set_offsets(cpi, mi_row + y_idx, mi_col + x_idx, BLOCK_SIZE_MB16X16); xd->mb_index = i; update_state(cpi, &x->mb_context[xd->sb_index][i], BLOCK_SIZE_MB16X16, output_enabled); @@ -840,9 +867,9 @@ static void encode_sb(VP9_COMP *cpi, vp9_activity_masking(cpi, x); encode_macroblock(cpi, tp, - output_enabled, mb_row + y_idx, mb_col + x_idx); + output_enabled, mi_row + y_idx, mi_col + x_idx); if (output_enabled) { - update_stats(cpi, mb_row + y_idx, mb_col + x_idx); + update_stats(cpi, mi_row + y_idx, mi_col + x_idx); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -850,8 +877,8 @@ static void encode_sb(VP9_COMP *cpi, } } - xd->above_seg_context = cm->above_seg_context + mb_col; - xd->left_seg_context = cm->left_seg_context + (mb_row & 3); + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); + xd->left_seg_context = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3); update_partition_context(xd, is_sb, BLOCK_SIZE_SB32X32); // debug output @@ -866,8 +893,8 @@ static void encode_sb(VP9_COMP *cpi, } static void encode_sb64(VP9_COMP *cpi, - int mb_row, - int mb_col, + int mi_row, + int mi_col, TOKENEXTRA **tp, BLOCK_SIZE_TYPE is_sb[4]) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; @@ -875,16 +902,16 @@ static void encode_sb64(VP9_COMP *cpi, BLOCK_SIZE_TYPE bsize = BLOCK_SIZE_SB64X64; int pl; - xd->left_seg_context = cm->left_seg_context + (mb_row & 3); - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->left_seg_context = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3); + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, bsize); if (is_sb[0] == BLOCK_SIZE_SB64X64) { - set_offsets(cpi, mb_row, mb_col, bsize); + set_offsets(cpi, mi_row, mi_col, bsize); update_state(cpi, &x->sb64_context, bsize, 1); encode_superblock(cpi, tp, - 1, mb_row, mb_col, bsize); - update_stats(cpi, mb_row, mb_col); + 1, mi_row, mi_col, bsize); + update_stats(cpi, mi_row, mi_col); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -893,12 +920,14 @@ static void encode_sb64(VP9_COMP *cpi, int i; cpi->partition_count[pl][PARTITION_VERT]++; - for (i = 0; i < 2 && mb_col + i * 2 != cm->mb_cols; i++) { - set_offsets(cpi, mb_row, mb_col + i * 2, BLOCK_SIZE_SB32X64); + for (i = 0; i < 2 && mi_col + (i * 2 << CONFIG_SB8X8) != cm->mi_cols; i++) { + set_offsets(cpi, mi_row, mi_col + (i * 2 << CONFIG_SB8X8), + BLOCK_SIZE_SB32X64); update_state(cpi, &x->sb32x64_context[i], BLOCK_SIZE_SB32X64, 1); encode_superblock(cpi, tp, - 1, mb_row, mb_col + i * 2, BLOCK_SIZE_SB32X64); - update_stats(cpi, mb_row, mb_col + i * 2); + 1, mi_row, mi_col + (i * 2 << CONFIG_SB8X8), + BLOCK_SIZE_SB32X64); + update_stats(cpi, mi_row, mi_col + (i * 2 << CONFIG_SB8X8)); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -907,12 +936,14 @@ static void encode_sb64(VP9_COMP *cpi, int i; cpi->partition_count[pl][PARTITION_HORZ]++; - for (i = 0; i < 2 && mb_row + i * 2 != cm->mb_rows; i++) { - set_offsets(cpi, mb_row + i * 2, mb_col, BLOCK_SIZE_SB64X32); + for (i = 0; i < 2 && mi_row + (i * 2 << CONFIG_SB8X8) != cm->mi_rows; i++) { + set_offsets(cpi, mi_row + (i * 2 << CONFIG_SB8X8), mi_col, + BLOCK_SIZE_SB64X32); update_state(cpi, &x->sb64x32_context[i], BLOCK_SIZE_SB64X32, 1); encode_superblock(cpi, tp, - 1, mb_row + i * 2, mb_col, BLOCK_SIZE_SB64X32); - update_stats(cpi, mb_row + i * 2, mb_col); + 1, mi_row + (i * 2 << CONFIG_SB8X8), mi_col, + BLOCK_SIZE_SB64X32); + update_stats(cpi, mi_row + (i * 2 << CONFIG_SB8X8), mi_col); (*tp)->token = EOSB_TOKEN; (*tp)++; @@ -921,42 +952,43 @@ static void encode_sb64(VP9_COMP *cpi, int i; cpi->partition_count[pl][PARTITION_SPLIT]++; for (i = 0; i < 4; i++) { - const int x_idx = i & 1, y_idx = i >> 1; + const int x_idx = (i & 1) << (1 + CONFIG_SB8X8); + const int y_idx = (i & 2) << CONFIG_SB8X8; - if (mb_row + y_idx * 2 >= cm->mb_rows || - mb_col + x_idx * 2 >= cm->mb_cols) { + if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols) { // MB lies outside frame, move on continue; } xd->sb_index = i; - encode_sb(cpi, mb_row + 2 * y_idx, mb_col + 2 * x_idx, 1, tp, + encode_sb(cpi, mi_row + y_idx, mi_col + x_idx, 1, tp, is_sb[i]); } } if (is_sb[0] > BLOCK_SIZE_SB32X32) { - xd->above_seg_context = cm->above_seg_context + mb_col; - xd->left_seg_context = cm->left_seg_context + (mb_row & 3); + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); + xd->left_seg_context = + cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3); update_partition_context(xd, is_sb[0], BLOCK_SIZE_SB64X64); } } static void encode_sb_row(VP9_COMP *cpi, - int mb_row, + int mi_row, TOKENEXTRA **tp, int *totalrate) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; - int mb_col, pl; + int mi_col, pl; // Initialize the left context for the new SB row vpx_memset(cm->left_context, 0, sizeof(cm->left_context)); vpx_memset(cm->left_seg_context, 0, sizeof(cm->left_seg_context)); // Code each SB in the row - for (mb_col = cm->cur_tile_mb_col_start; - mb_col < cm->cur_tile_mb_col_end; mb_col += 4) { + for (mi_col = cm->cur_tile_mi_col_start; + mi_col < cm->cur_tile_mi_col_end; mi_col += (4 << CONFIG_SB8X8)) { int i; BLOCK_SIZE_TYPE sb_partitioning[4]; int sb64_rate = 0, sb64_dist = 0; @@ -965,35 +997,39 @@ static void encode_sb_row(VP9_COMP *cpi, PARTITION_CONTEXT seg_l[4], seg_a[4]; TOKENEXTRA *tp_orig = *tp; - memcpy(&a, cm->above_context + mb_col, sizeof(a)); + memcpy(&a, cm->above_context + (mi_col >> CONFIG_SB8X8), sizeof(a)); memcpy(&l, cm->left_context, sizeof(l)); - memcpy(&seg_a, cm->above_seg_context + mb_col, sizeof(seg_a)); + memcpy(&seg_a, cm->above_seg_context + (mi_col >> CONFIG_SB8X8), + sizeof(seg_a)); memcpy(&seg_l, cm->left_seg_context, sizeof(seg_l)); for (i = 0; i < 4; i++) { - const int x_idx = (i & 1) << 1, y_idx = i & 2; + const int x_idx = (i & 1) << (1 + CONFIG_SB8X8); + const int y_idx = (i & 2) << CONFIG_SB8X8; int sb32_rate = 0, sb32_dist = 0; int splitmodes_used = 0; int sb32_skip = 0; int j; ENTROPY_CONTEXT_PLANES l2[2], a2[2]; - if (mb_row + y_idx >= cm->mb_rows || mb_col + x_idx >= cm->mb_cols) + if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols) continue; xd->sb_index = i; /* Function should not modify L & A contexts; save and restore on exit */ - vpx_memcpy(l2, cm->left_context + y_idx, sizeof(l2)); - vpx_memcpy(a2, cm->above_context + mb_col + x_idx, sizeof(a2)); + vpx_memcpy(l2, cm->left_context + (y_idx >> CONFIG_SB8X8), sizeof(l2)); + vpx_memcpy(a2, cm->above_context + ((mi_col + x_idx) >> CONFIG_SB8X8), + sizeof(a2)); /* Encode MBs in raster order within the SB */ sb_partitioning[i] = BLOCK_SIZE_MB16X16; for (j = 0; j < 4; j++) { - const int x_idx_m = x_idx + (j & 1), y_idx_m = y_idx + (j >> 1); + const int x_idx_m = x_idx + ((j & 1) << CONFIG_SB8X8); + const int y_idx_m = y_idx + ((j >> 1) << CONFIG_SB8X8); int r, d; - if (mb_row + y_idx_m >= cm->mb_rows || - mb_col + x_idx_m >= cm->mb_cols) { + if (mi_row + y_idx_m >= cm->mi_rows || + mi_col + x_idx_m >= cm->mi_cols) { // MB lies outside frame, move on continue; } @@ -1001,22 +1037,28 @@ static void encode_sb_row(VP9_COMP *cpi, // Index of the MB in the SB 0..3 xd->mb_index = j; - splitmodes_used += pick_mb_mode(cpi, mb_row + y_idx_m, - mb_col + x_idx_m, tp, &r, &d); + splitmodes_used += pick_mb_mode(cpi, mi_row + y_idx_m, + mi_col + x_idx_m, tp, &r, &d); sb32_rate += r; sb32_dist += d; // Dummy encode, do not do the tokenization - encode_macroblock(cpi, tp, 0, mb_row + y_idx_m, - mb_col + x_idx_m); +#if CONFIG_SB8X8 + update_state(cpi, &x->mb_context[xd->sb_index][xd->mb_index], + BLOCK_SIZE_MB16X16, 0); +#endif + encode_macroblock(cpi, tp, 0, mi_row + y_idx_m, + mi_col + x_idx_m); } /* Restore L & A coding context to those in place on entry */ - vpx_memcpy(cm->left_context + y_idx, l2, sizeof(l2)); - vpx_memcpy(cm->above_context + mb_col + x_idx, a2, sizeof(a2)); + vpx_memcpy(cm->left_context + (y_idx >> CONFIG_SB8X8), l2, sizeof(l2)); + vpx_memcpy(cm->above_context + ((mi_col + x_idx) >> CONFIG_SB8X8), a2, + sizeof(a2)); - xd->left_seg_context = cm->left_seg_context + (y_idx & 3); - xd->above_seg_context = cm->above_seg_context + mb_col + x_idx; + xd->left_seg_context = cm->left_seg_context + (y_idx >> CONFIG_SB8X8); + xd->above_seg_context = + cm->above_seg_context + ((mi_col + x_idx) >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32); sb32_rate += x->partition_cost[pl][PARTITION_SPLIT]; @@ -1026,31 +1068,32 @@ static void encode_sb_row(VP9_COMP *cpi, } // check 32x16 - if (mb_col + x_idx + 1 < cm->mb_cols) { + if (mi_col + x_idx + (2 << CONFIG_SB8X8) <= cm->mi_cols) { int r, d; xd->mb_index = 0; - pick_sb_modes(cpi, mb_row + y_idx, mb_col + x_idx, + pick_sb_modes(cpi, mi_row + y_idx, mi_col + x_idx, tp, &r, &d, BLOCK_SIZE_SB32X16, &x->sb32x16_context[xd->sb_index][xd->mb_index]); - if (mb_row + y_idx + 1 < cm->mb_rows) { + if (mi_row + y_idx + (1 << CONFIG_SB8X8) < cm->mi_rows) { int r2, d2; update_state(cpi, &x->sb32x16_context[xd->sb_index][xd->mb_index], BLOCK_SIZE_SB32X16, 0); encode_superblock(cpi, tp, - 0, mb_row + y_idx, mb_col + x_idx, + 0, mi_row + y_idx, mi_col + x_idx, BLOCK_SIZE_SB32X16); xd->mb_index = 1; - pick_sb_modes(cpi, mb_row + y_idx + 1, mb_col + x_idx, - tp, &r2, &d2, BLOCK_SIZE_SB32X16, + pick_sb_modes(cpi, mi_row + y_idx + (1 << CONFIG_SB8X8), + mi_col + x_idx, tp, &r2, &d2, BLOCK_SIZE_SB32X16, &x->sb32x16_context[xd->sb_index][xd->mb_index]); r += r2; d += d2; } - xd->left_seg_context = cm->left_seg_context + (y_idx & 3); - xd->above_seg_context = cm->above_seg_context + mb_col + x_idx; + xd->left_seg_context = cm->left_seg_context + (y_idx >> CONFIG_SB8X8); + xd->above_seg_context = + cm->above_seg_context + ((mi_col + x_idx) >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32); r += x->partition_cost[pl][PARTITION_HORZ]; @@ -1062,36 +1105,40 @@ static void encode_sb_row(VP9_COMP *cpi, sb_partitioning[i] = BLOCK_SIZE_SB32X16; } - vpx_memcpy(cm->left_context + y_idx, l2, sizeof(l2)); - vpx_memcpy(cm->above_context + mb_col + x_idx, a2, sizeof(a2)); + vpx_memcpy(cm->left_context + (y_idx >> CONFIG_SB8X8), l2, sizeof(l2)); + vpx_memcpy(cm->above_context + ((mi_col + x_idx) >> CONFIG_SB8X8), a2, + sizeof(a2)); } // check 16x32 - if (mb_row + y_idx + 1 < cm->mb_rows) { + if (mi_row + y_idx + (2 << CONFIG_SB8X8) <= cm->mi_rows) { int r, d; xd->mb_index = 0; - pick_sb_modes(cpi, mb_row + y_idx, mb_col + x_idx, + pick_sb_modes(cpi, mi_row + y_idx, mi_col + x_idx, tp, &r, &d, BLOCK_SIZE_SB16X32, &x->sb16x32_context[xd->sb_index][xd->mb_index]); - if (mb_col + x_idx + 1 < cm->mb_cols) { + if (mi_col + x_idx + (1 << CONFIG_SB8X8) < cm->mi_cols) { int r2, d2; update_state(cpi, &x->sb16x32_context[xd->sb_index][xd->mb_index], BLOCK_SIZE_SB16X32, 0); encode_superblock(cpi, tp, - 0, mb_row + y_idx, mb_col + x_idx, + 0, mi_row + y_idx, mi_col + x_idx, BLOCK_SIZE_SB16X32); xd->mb_index = 1; - pick_sb_modes(cpi, mb_row + y_idx, mb_col + x_idx + 1, + pick_sb_modes(cpi, mi_row + y_idx, + mi_col + x_idx + (1 << CONFIG_SB8X8), tp, &r2, &d2, BLOCK_SIZE_SB16X32, &x->sb16x32_context[xd->sb_index][xd->mb_index]); r += r2; d += d2; } - xd->left_seg_context = cm->left_seg_context + (y_idx & 3); - xd->above_seg_context = cm->above_seg_context + mb_col + x_idx; + xd->left_seg_context = + cm->left_seg_context + (y_idx >> CONFIG_SB8X8); + xd->above_seg_context = + cm->above_seg_context + ((mi_col + x_idx) >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32); r += x->partition_cost[pl][PARTITION_VERT]; @@ -1103,21 +1150,24 @@ static void encode_sb_row(VP9_COMP *cpi, sb_partitioning[i] = BLOCK_SIZE_SB16X32; } - vpx_memcpy(cm->left_context + y_idx, l2, sizeof(l2)); - vpx_memcpy(cm->above_context + mb_col + x_idx, a2, sizeof(a2)); + vpx_memcpy(cm->left_context + (y_idx >> CONFIG_SB8X8), l2, sizeof(l2)); + vpx_memcpy(cm->above_context + ((mi_col + x_idx) >> CONFIG_SB8X8), a2, + sizeof(a2)); } - if (!sb32_skip && !(mb_col + x_idx + 1 >= cm->mb_cols || - mb_row + y_idx + 1 >= cm->mb_rows)) { + if (!sb32_skip && + mi_col + x_idx + (2 << CONFIG_SB8X8) <= cm->mi_cols && + mi_row + y_idx + (2 << CONFIG_SB8X8) <= cm->mi_rows) { int r, d; /* Pick a mode assuming that it applies to all 4 of the MBs in the SB */ - pick_sb_modes(cpi, mb_row + y_idx, mb_col + x_idx, + pick_sb_modes(cpi, mi_row + y_idx, mi_col + x_idx, tp, &r, &d, BLOCK_SIZE_SB32X32, &x->sb32_context[xd->sb_index]); - xd->left_seg_context = cm->left_seg_context + (y_idx & 3); - xd->above_seg_context = cm->above_seg_context + mb_col + x_idx; + xd->left_seg_context = cm->left_seg_context + (y_idx >> CONFIG_SB8X8); + xd->above_seg_context = + cm->above_seg_context + ((mi_col + x_idx) >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32); r += x->partition_cost[pl][PARTITION_NONE]; @@ -1143,37 +1193,38 @@ static void encode_sb_row(VP9_COMP *cpi, // pixels of the lower level; also, inverting SB/MB order (big->small // instead of small->big) means we can use as threshold for small, which // may enable breakouts if RD is not good enough (i.e. faster) - encode_sb(cpi, mb_row + y_idx, mb_col + x_idx, 0, tp, + encode_sb(cpi, mi_row + y_idx, mi_col + x_idx, 0, tp, sb_partitioning[i]); } - memcpy(cm->above_context + mb_col, &a, sizeof(a)); + memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), &a, sizeof(a)); memcpy(cm->left_context, &l, sizeof(l)); - memcpy(cm->above_seg_context + mb_col, &seg_a, sizeof(seg_a)); + memcpy(cm->above_seg_context + (mi_col >> CONFIG_SB8X8), &seg_a, + sizeof(seg_a)); memcpy(cm->left_seg_context, &seg_l, sizeof(seg_l)); xd->left_seg_context = cm->left_seg_context; - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64); sb64_rate += x->partition_cost[pl][PARTITION_SPLIT]; // check 64x32 - if (mb_col + 3 < cm->mb_cols && !(cm->mb_rows & 1)) { + if (mi_col + (4 << CONFIG_SB8X8) <= cm->mi_cols && !(cm->mb_rows & 1)) { int r, d; xd->sb_index = 0; - pick_sb_modes(cpi, mb_row, mb_col, + pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, BLOCK_SIZE_SB64X32, &x->sb64x32_context[xd->sb_index]); - if (mb_row + 2 != cm->mb_rows) { + if (mi_row + (2 << CONFIG_SB8X8) != cm->mi_rows) { int r2, d2; update_state(cpi, &x->sb64x32_context[xd->sb_index], BLOCK_SIZE_SB64X32, 0); encode_superblock(cpi, tp, - 0, mb_row, mb_col, BLOCK_SIZE_SB64X32); + 0, mi_row, mi_col, BLOCK_SIZE_SB64X32); xd->sb_index = 1; - pick_sb_modes(cpi, mb_row + 2, mb_col, + pick_sb_modes(cpi, mi_row + (2 << CONFIG_SB8X8), mi_col, tp, &r2, &d2, BLOCK_SIZE_SB64X32, &x->sb64x32_context[xd->sb_index]); r += r2; @@ -1181,7 +1232,7 @@ static void encode_sb_row(VP9_COMP *cpi, } xd->left_seg_context = cm->left_seg_context; - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64); r += x->partition_cost[pl][PARTITION_HORZ]; @@ -1194,26 +1245,26 @@ static void encode_sb_row(VP9_COMP *cpi, } vpx_memcpy(cm->left_context, l, sizeof(l)); - vpx_memcpy(cm->above_context + mb_col, a, sizeof(a)); + vpx_memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), a, sizeof(a)); } // check 32x64 - if (mb_row + 3 < cm->mb_rows && !(cm->mb_cols & 1)) { + if (mi_row + (4 << CONFIG_SB8X8) <= cm->mi_rows && !(cm->mb_cols & 1)) { int r, d; xd->sb_index = 0; - pick_sb_modes(cpi, mb_row, mb_col, + pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, BLOCK_SIZE_SB32X64, &x->sb32x64_context[xd->sb_index]); - if (mb_col + 2 != cm->mb_cols) { + if (mi_col + (2 << CONFIG_SB8X8) != cm->mi_cols) { int r2, d2; update_state(cpi, &x->sb32x64_context[xd->sb_index], BLOCK_SIZE_SB32X64, 0); encode_superblock(cpi, tp, - 0, mb_row, mb_col, BLOCK_SIZE_SB32X64); + 0, mi_row, mi_col, BLOCK_SIZE_SB32X64); xd->sb_index = 1; - pick_sb_modes(cpi, mb_row, mb_col + 2, + pick_sb_modes(cpi, mi_row, mi_col + (2 << CONFIG_SB8X8), tp, &r2, &d2, BLOCK_SIZE_SB32X64, &x->sb32x64_context[xd->sb_index]); r += r2; @@ -1221,7 +1272,7 @@ static void encode_sb_row(VP9_COMP *cpi, } xd->left_seg_context = cm->left_seg_context; - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64); r += x->partition_cost[pl][PARTITION_VERT]; @@ -1234,18 +1285,19 @@ static void encode_sb_row(VP9_COMP *cpi, } vpx_memcpy(cm->left_context, l, sizeof(l)); - vpx_memcpy(cm->above_context + mb_col, a, sizeof(a)); + vpx_memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), a, sizeof(a)); } - if (!sb64_skip && !(mb_col + 3 >= cm->mb_cols || - mb_row + 3 >= cm->mb_rows)) { + if (!sb64_skip && + mi_col + (4 << CONFIG_SB8X8) <= cm->mi_cols && + mi_row + (4 << CONFIG_SB8X8) <= cm->mi_rows) { int r, d; - pick_sb_modes(cpi, mb_row, mb_col, tp, &r, &d, + pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, BLOCK_SIZE_SB64X64, &x->sb64_context); xd->left_seg_context = cm->left_seg_context; - xd->above_seg_context = cm->above_seg_context + mb_col; + xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8); pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64); r += x->partition_cost[pl][PARTITION_NONE]; @@ -1258,7 +1310,7 @@ static void encode_sb_row(VP9_COMP *cpi, } assert(tp_orig == *tp); - encode_sb64(cpi, mb_row, mb_col, tp, sb_partitioning); + encode_sb64(cpi, mi_row, mi_col, tp, sb_partitioning); assert(tp_orig < *tp); } } @@ -1342,7 +1394,7 @@ static void switch_lossless_mode(VP9_COMP *cpi, int lossless) { static void encode_frame_internal(VP9_COMP *cpi) { - int mb_row; + int mi_row; MACROBLOCK *const x = &cpi->mb; VP9_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &x->e_mbd; @@ -1440,9 +1492,10 @@ static void encode_frame_internal(VP9_COMP *cpi) { // For each row of SBs in the frame vp9_get_tile_col_offsets(cm, tile_col); - for (mb_row = cm->cur_tile_mb_row_start; - mb_row < cm->cur_tile_mb_row_end; mb_row += 4) { - encode_sb_row(cpi, mb_row, &tp, &totalrate); + for (mi_row = cm->cur_tile_mi_row_start; + mi_row < cm->cur_tile_mi_row_end; + mi_row += (4 << CONFIG_SB8X8)) { + encode_sb_row(cpi, mi_row, &tp, &totalrate); } cpi->tok_count[tile_col] = (unsigned int)(tp - tp_old); assert(tp - cpi->tok <= @@ -1513,7 +1566,7 @@ static void set_txfm_flag(MODE_INFO *mi, int mis, int ymbs, int xmbs, static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi, int mis, TX_SIZE txfm_max, - int mb_rows_left, int mb_cols_left, + int mi_rows_left, int mi_cols_left, BLOCK_SIZE_TYPE bsize) { MB_MODE_INFO *const mbmi = &mi->mbmi; @@ -1521,9 +1574,9 @@ static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi, MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; const int segment_id = mbmi->segment_id; - const int bh = 1 << mb_height_log2(bsize), bw = 1 << mb_width_log2(bsize); - const int ymbs = MIN(bh, mb_rows_left); - const int xmbs = MIN(bw, mb_cols_left); + const int bh = 1 << mi_height_log2(bsize), bw = 1 << mi_width_log2(bsize); + const int ymbs = MIN(bh, mi_rows_left); + const int xmbs = MIN(bw, mi_cols_left); xd->mode_info_context = mi; assert(vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP) || @@ -1534,87 +1587,96 @@ static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi, static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) { VP9_COMMON *const cm = &cpi->common; - int mb_row, mb_col; + int mi_row, mi_col; const int mis = cm->mode_info_stride; MODE_INFO *mi, *mi_ptr = cm->mi; - for (mb_row = 0; mb_row < cm->mb_rows; mb_row += 4, mi_ptr += 4 * mis) { + for (mi_row = 0; mi_row < cm->mi_rows; + mi_row += (4 << CONFIG_SB8X8), mi_ptr += (4 << CONFIG_SB8X8) * mis) { mi = mi_ptr; - for (mb_col = 0; mb_col < cm->mb_cols; mb_col += 4, mi += 4) { + for (mi_col = 0; mi_col < cm->mi_cols; + mi_col += (4 << CONFIG_SB8X8), mi += (4 << CONFIG_SB8X8)) { if (mi->mbmi.sb_type == BLOCK_SIZE_SB64X64) { reset_skip_txfm_size_sb(cpi, mi, mis, txfm_max, - cm->mb_rows - mb_row, cm->mb_cols - mb_col, + cm->mi_rows - mi_row, cm->mi_cols - mi_col, BLOCK_SIZE_SB64X64); } else if (mi->mbmi.sb_type == BLOCK_SIZE_SB64X32) { reset_skip_txfm_size_sb(cpi, mi, mis, txfm_max, - cm->mb_rows - mb_row, cm->mb_cols - mb_col, + cm->mi_rows - mi_row, cm->mi_cols - mi_col, BLOCK_SIZE_SB64X32); - if (mb_row + 2 != cm->mb_rows) - reset_skip_txfm_size_sb(cpi, mi + 2 * mis, mis, txfm_max, - cm->mb_rows - mb_row - 2, - cm->mb_cols - mb_col, + if (mi_row + (2 << CONFIG_SB8X8) != cm->mi_rows) + reset_skip_txfm_size_sb(cpi, mi + (2 << CONFIG_SB8X8) * mis, mis, + txfm_max, + cm->mi_rows - mi_row - (2 << CONFIG_SB8X8), + cm->mi_cols - mi_col, BLOCK_SIZE_SB64X32); } else if (mi->mbmi.sb_type == BLOCK_SIZE_SB32X64) { reset_skip_txfm_size_sb(cpi, mi, mis, txfm_max, - cm->mb_rows - mb_row, cm->mb_cols - mb_col, + cm->mi_rows - mi_row, cm->mi_cols - mi_col, BLOCK_SIZE_SB32X64); - if (mb_col + 2 != cm->mb_cols) - reset_skip_txfm_size_sb(cpi, mi + 2, mis, txfm_max, - cm->mb_rows - mb_row, - cm->mb_cols - mb_col - 2, + if (mi_col + (2 << CONFIG_SB8X8) != cm->mi_cols) + reset_skip_txfm_size_sb(cpi, mi + (2 << CONFIG_SB8X8), mis, txfm_max, + cm->mi_rows - mi_row, + cm->mi_cols - mi_col - (2 << CONFIG_SB8X8), BLOCK_SIZE_SB32X64); } else { int i; for (i = 0; i < 4; i++) { - const int x_idx_sb = (i & 1) << 1, y_idx_sb = i & 2; + const int x_idx_sb = (i & 1) << (1 + CONFIG_SB8X8); + const int y_idx_sb = (i & 2) << CONFIG_SB8X8; MODE_INFO *sb_mi = mi + y_idx_sb * mis + x_idx_sb; - if (mb_row + y_idx_sb >= cm->mb_rows || - mb_col + x_idx_sb >= cm->mb_cols) + if (mi_row + y_idx_sb >= cm->mi_rows || + mi_col + x_idx_sb >= cm->mi_cols) continue; if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB32X32) { reset_skip_txfm_size_sb(cpi, sb_mi, mis, txfm_max, - cm->mb_rows - mb_row - y_idx_sb, - cm->mb_cols - mb_col - x_idx_sb, + cm->mi_rows - mi_row - y_idx_sb, + cm->mi_cols - mi_col - x_idx_sb, BLOCK_SIZE_SB32X32); } else if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB32X16) { reset_skip_txfm_size_sb(cpi, sb_mi, mis, txfm_max, - cm->mb_rows - mb_row - y_idx_sb, - cm->mb_cols - mb_col - x_idx_sb, + cm->mi_rows - mi_row - y_idx_sb, + cm->mi_cols - mi_col - x_idx_sb, BLOCK_SIZE_SB32X16); - if (mb_row + y_idx_sb + 1 != cm->mb_rows) - reset_skip_txfm_size_sb(cpi, sb_mi + mis, mis, txfm_max, - cm->mb_rows - mb_row - y_idx_sb - 1, - cm->mb_cols - mb_col - x_idx_sb, + if (mi_row + y_idx_sb + (1 << CONFIG_SB8X8) != cm->mi_rows) + reset_skip_txfm_size_sb(cpi, sb_mi + (mis << CONFIG_SB8X8), mis, + txfm_max, + cm->mi_rows - mi_row - y_idx_sb - + (1 << CONFIG_SB8X8), + cm->mi_cols - mi_col - x_idx_sb, BLOCK_SIZE_SB32X16); } else if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB16X32) { reset_skip_txfm_size_sb(cpi, sb_mi, mis, txfm_max, - cm->mb_rows - mb_row - y_idx_sb, - cm->mb_cols - mb_col - x_idx_sb, + cm->mi_rows - mi_row - y_idx_sb, + cm->mi_cols - mi_col - x_idx_sb, BLOCK_SIZE_SB16X32); - if (mb_col + x_idx_sb + 1 != cm->mb_cols) - reset_skip_txfm_size_sb(cpi, sb_mi + 1, mis, txfm_max, - cm->mb_rows - mb_row - y_idx_sb, - cm->mb_cols - mb_col - x_idx_sb - 1, + if (mi_col + x_idx_sb + (1 << CONFIG_SB8X8) != cm->mi_cols) + reset_skip_txfm_size_sb(cpi, sb_mi + (1 << CONFIG_SB8X8), mis, + txfm_max, + cm->mi_rows - mi_row - y_idx_sb, + cm->mi_cols - mi_col - x_idx_sb - + (1 << CONFIG_SB8X8), BLOCK_SIZE_SB16X32); } else { int m; for (m = 0; m < 4; m++) { - const int x_idx = x_idx_sb + (m & 1), y_idx = y_idx_sb + (m >> 1); + const int x_idx = x_idx_sb + ((m & 1) << CONFIG_SB8X8); + const int y_idx = y_idx_sb + ((m >> 1) << CONFIG_SB8X8); MODE_INFO *mb_mi; - if (mb_col + x_idx >= cm->mb_cols || - mb_row + y_idx >= cm->mb_rows) + if (mi_col + x_idx >= cm->mi_cols || + mi_row + y_idx >= cm->mi_rows) continue; mb_mi = mi + y_idx * mis + x_idx; assert(mb_mi->mbmi.sb_type == BLOCK_SIZE_MB16X16); reset_skip_txfm_size_sb(cpi, mb_mi, mis, txfm_max, - cm->mb_rows - mb_row - y_idx, - cm->mb_cols - mb_col - x_idx, + cm->mi_rows - mi_row - y_idx, + cm->mi_cols - mi_col - x_idx, BLOCK_SIZE_MB16X16); } } @@ -1858,13 +1920,16 @@ static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x) { static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled, - int mb_row, int mb_col) { + int mi_row, int mi_col) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; MODE_INFO *mi = xd->mode_info_context; MB_MODE_INFO *const mbmi = &mi->mbmi; const int mis = cm->mode_info_stride; +#if CONFIG_SB8X8 + int n; +#endif assert(xd->mode_info_context->mbmi.sb_type == BLOCK_SIZE_MB16X16); @@ -1963,12 +2028,12 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t, &cpi->common.yv12_fb[ref_fb_idx], mbmi->second_ref_frame > 0 ? &cpi->common.yv12_fb[second_ref_fb_idx] : NULL, - mb_row, mb_col, xd->scale_factor, xd->scale_factor_uv); + mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv); if (!x->skip) { - vp9_encode_inter16x16(cm, x, mb_row, mb_col); + vp9_encode_inter16x16(cm, x, mi_row, mi_col); } else { - vp9_build_inter_predictors_sb(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16); + vp9_build_inter_predictors_sb(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16); #if CONFIG_COMP_INTERINTRA_PRED if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) { vp9_build_interintra_predictors(xd, @@ -2049,6 +2114,16 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t, vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16); } +#if CONFIG_SB8X8 + // copy skip flag on all mb_mode_info contexts in this SB + // if this was a skip at this txfm size + for (n = 1; n < 4; n++) { + const int x_idx = n & 1, y_idx = n >> 1; + if (mi_col + x_idx < cm->mi_cols && mi_row + y_idx < cm->mi_rows) + mi[x_idx + y_idx * mis].mbmi.mb_skip_coeff = mi->mbmi.mb_skip_coeff; + } +#endif + if (output_enabled) { int segment_id = mbmi->segment_id; if (cpi->common.txfm_mode == TX_MODE_SELECT && @@ -2063,22 +2138,38 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t, mbmi->partitioning != PARTITIONING_4X4)) { cpi->txfm_count_8x8p[mbmi->txfm_size]++; } - } else if (mbmi->mode != I4X4_PRED && mbmi->mode != I8X8_PRED && - mbmi->mode != SPLITMV && cpi->common.txfm_mode >= ALLOW_16X16) { - mbmi->txfm_size = TX_16X16; - } else if (mbmi->mode != I4X4_PRED && - !(mbmi->mode == SPLITMV && - mbmi->partitioning == PARTITIONING_4X4) && - cpi->common.txfm_mode >= ALLOW_8X8) { - mbmi->txfm_size = TX_8X8; } else { - mbmi->txfm_size = TX_4X4; +#if CONFIG_SB8X8 + int y, x; +#endif + + if (mbmi->mode != I4X4_PRED && mbmi->mode != I8X8_PRED && + mbmi->mode != SPLITMV && cpi->common.txfm_mode >= ALLOW_16X16) { + mbmi->txfm_size = TX_16X16; + } else if (mbmi->mode != I4X4_PRED && + !(mbmi->mode == SPLITMV && + mbmi->partitioning == PARTITIONING_4X4) && + cpi->common.txfm_mode >= ALLOW_8X8) { + mbmi->txfm_size = TX_8X8; + } else { + mbmi->txfm_size = TX_4X4; + } + +#if CONFIG_SB8X8 + for (y = 0; y < 2; y++) { + for (x = !y; x < 2; x++) { + if (mi_col + x < cm->mi_cols && mi_row + y < cm->mi_rows) { + mi[mis * y + x].mbmi.txfm_size = mbmi->txfm_size; + } + } + } +#endif } } } static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, - int output_enabled, int mb_row, int mb_col, + int output_enabled, int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) { VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; @@ -2087,8 +2178,8 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, MODE_INFO *mi = x->e_mbd.mode_info_context; unsigned int segment_id = mi->mbmi.segment_id; const int mis = cm->mode_info_stride; - const int bwl = mb_width_log2(bsize); - const int bw = 1 << bwl, bh = 1 << mb_height_log2(bsize); + const int bwl = mi_width_log2(bsize); + const int bw = 1 << bwl, bh = 1 << mi_height_log2(bsize); if (cm->frame_type == KEY_FRAME) { if (cpi->oxcf.tuning == VP8_TUNE_SSIM) { @@ -2156,9 +2247,9 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, &cpi->common.yv12_fb[ref_fb_idx], xd->mode_info_context->mbmi.second_ref_frame > 0 ? &cpi->common.yv12_fb[second_ref_fb_idx] : NULL, - mb_row, mb_col, xd->scale_factor, xd->scale_factor_uv); + mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv); - vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize); + vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize); } if (!x->skip) { @@ -2254,7 +2345,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, // if this was a skip at this txfm size for (n = 1; n < bw * bh; n++) { const int x_idx = n & (bw - 1), y_idx = n >> bwl; - if (mb_col + x_idx < cm->mb_cols && mb_row + y_idx < cm->mb_rows) + if (mi_col + x_idx < cm->mi_cols && mi_row + y_idx < cm->mi_rows) mi[x_idx + y_idx * mis].mbmi.mb_skip_coeff = mi->mbmi.mb_skip_coeff; } @@ -2276,7 +2367,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, for (y = 0; y < bh; y++) { for (x = 0; x < bw; x++) { - if (mb_col + x < cm->mb_cols && mb_row + y < cm->mb_rows) { + if (mi_col + x < cm->mi_cols && mi_row + y < cm->mi_rows) { mi[mis * y + x].mbmi.txfm_size = sz; } } diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c index a11bb3ecf..0823316c9 100644 --- a/vp9/encoder/vp9_encodemb.c +++ b/vp9/encoder/vp9_encodemb.c @@ -764,20 +764,20 @@ void vp9_fidct_mb(VP9_COMMON *const cm, MACROBLOCK *x) { } void vp9_encode_inter16x16(VP9_COMMON *const cm, MACROBLOCK *x, - int mb_row, int mb_col) { + int mi_row, int mi_col) { MACROBLOCKD *const xd = &x->e_mbd; - vp9_build_inter_predictors_sb(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16); + vp9_build_inter_predictors_sb(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16); vp9_subtract_sb(x, BLOCK_SIZE_MB16X16); vp9_fidct_mb(cm, x); vp9_recon_sb(xd, BLOCK_SIZE_MB16X16); } /* this function is used by first pass only */ -void vp9_encode_inter16x16y(MACROBLOCK *x, int mb_row, int mb_col) { +void vp9_encode_inter16x16y(MACROBLOCK *x, int mi_row, int mi_col) { MACROBLOCKD *xd = &x->e_mbd; - vp9_build_inter_predictors_sby(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16); + vp9_build_inter_predictors_sby(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16); vp9_subtract_sby(x, BLOCK_SIZE_MB16X16); vp9_transform_sby_4x4(x, BLOCK_SIZE_MB16X16); diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c index 607cd9923..e4d68630d 100644 --- a/vp9/encoder/vp9_firstpass.c +++ b/vp9/encoder/vp9_firstpass.c @@ -520,9 +520,12 @@ void vp9_first_pass(VP9_COMP *cpi) { int gf_motion_error = INT_MAX; int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row); - set_mb_row_col(cm, xd, - mb_row, 1 << mb_height_log2(BLOCK_SIZE_MB16X16), - mb_col, 1 << mb_height_log2(BLOCK_SIZE_MB16X16)); + set_mi_row_col(cm, xd, + mb_row << CONFIG_SB8X8, + 1 << mi_height_log2(BLOCK_SIZE_MB16X16), + mb_col << CONFIG_SB8X8, + 1 << mi_height_log2(BLOCK_SIZE_MB16X16)); + xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset; xd->plane[1].dst.buf = new_yv12->u_buffer + recon_uvoffset; xd->plane[2].dst.buf = new_yv12->v_buffer + recon_uvoffset; diff --git a/vp9/encoder/vp9_mbgraph.c b/vp9/encoder/vp9_mbgraph.c index 27e9eceb0..fe5d114ba 100644 --- a/vp9/encoder/vp9_mbgraph.c +++ b/vp9/encoder/vp9_mbgraph.c @@ -386,10 +386,22 @@ static void separate_arf_mbs(VP9_COMP *cpi) { // goes in segment 0 if (arf_not_zz[offset + mb_col]) { ncnt[0]++; +#if CONFIG_SB8X8 + cpi->segmentation_map[offset * 4 + 2 * mb_col] = 0; + cpi->segmentation_map[offset * 4 + 2 * mb_col + 1] = 0; + cpi->segmentation_map[offset * 4 + 2 * mb_col + cm->mi_cols] = 0; + cpi->segmentation_map[offset * 4 + 2 * mb_col + cm->mi_cols + 1] = 0; + } else { + cpi->segmentation_map[offset * 4 + 2 * mb_col] = 1; + cpi->segmentation_map[offset * 4 + 2 * mb_col + 1] = 1; + cpi->segmentation_map[offset * 4 + 2 * mb_col + cm->mi_cols] = 1; + cpi->segmentation_map[offset * 4 + 2 * mb_col + cm->mi_cols + 1] = 1; +#else cpi->segmentation_map[offset + mb_col] = 0; } else { - ncnt[1]++; cpi->segmentation_map[offset + mb_col] = 1; +#endif + ncnt[1]++; } } } diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c index 0b64fe1d9..d557c6e25 100644 --- a/vp9/encoder/vp9_onyx_if.c +++ b/vp9/encoder/vp9_onyx_if.c @@ -379,7 +379,7 @@ static void configure_static_seg_features(VP9_COMP *cpi) { // Disable and clear down for KF if (cm->frame_type == KEY_FRAME) { // Clear down the global segmentation map - vpx_memset(cpi->segmentation_map, 0, (cm->mb_rows * cm->mb_cols)); + vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); xd->update_mb_segmentation_map = 0; xd->update_mb_segmentation_data = 0; #if CONFIG_IMPLICIT_SEGMENTATION @@ -395,7 +395,7 @@ static void configure_static_seg_features(VP9_COMP *cpi) { } else if (cpi->refresh_alt_ref_frame) { // If this is an alt ref frame // Clear down the global segmentation map - vpx_memset(cpi->segmentation_map, 0, (cm->mb_rows * cm->mb_cols)); + vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); xd->update_mb_segmentation_map = 0; xd->update_mb_segmentation_data = 0; #if CONFIG_IMPLICIT_SEGMENTATION @@ -460,8 +460,7 @@ static void configure_static_seg_features(VP9_COMP *cpi) { else { vp9_disable_segmentation((VP9_PTR)cpi); - vpx_memset(cpi->segmentation_map, 0, - (cm->mb_rows * cm->mb_cols)); + vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); xd->update_mb_segmentation_map = 0; xd->update_mb_segmentation_data = 0; @@ -549,8 +548,8 @@ static void print_seg_map(VP9_COMP *cpi) { fprintf(statsfile, "%10d\n", cm->current_video_frame); - for (row = 0; row < cpi->common.mb_rows; row++) { - for (col = 0; col < cpi->common.mb_cols; col++) { + for (row = 0; row < cpi->common.mi_rows; row++) { + for (col = 0; col < cpi->common.mi_cols; col++) { fprintf(statsfile, "%10d", cpi->segmentation_map[map_index]); map_index++; } @@ -567,13 +566,13 @@ static void update_reference_segmentation_map(VP9_COMP *cpi) { MODE_INFO *mi, *mi_ptr = cm->mi; uint8_t *cache_ptr = cm->last_frame_seg_map, *cache; - for (row = 0; row < cm->mb_rows; row++) { + for (row = 0; row < cm->mi_rows; row++) { mi = mi_ptr; cache = cache_ptr; - for (col = 0; col < cm->mb_cols; col++, mi++, cache++) + for (col = 0; col < cm->mi_cols; col++, mi++, cache++) cache[0] = mi->mbmi.segment_id; mi_ptr += cm->mode_info_stride; - cache_ptr += cm->mb_cols; + cache_ptr += cm->mi_cols; } } @@ -907,7 +906,7 @@ static int alloc_partition_data(VP9_COMP *cpi) { vpx_free(cpi->mb.pip); cpi->mb.pip = vpx_calloc((cpi->common.mode_info_stride) * - (cpi->common.mb_rows + 1), + (cpi->common.mi_rows + 1), sizeof(PARTITION_INFO)); if (!cpi->mb.pip) return 1; @@ -987,11 +986,13 @@ static void update_frame_size(VP9_COMP *cpi) { const int aligned_height = multiple16(cm->height); cm->mb_rows = aligned_height >> 4; + cm->mi_rows = aligned_height >> LOG2_MI_SIZE; cm->mb_cols = aligned_width >> 4; + cm->mi_cols = aligned_width >> LOG2_MI_SIZE; cm->MBs = cm->mb_rows * cm->mb_cols; - cm->mode_info_stride = cm->mb_cols + 1; + cm->mode_info_stride = cm->mi_cols + 1; memset(cm->mip, 0, - cm->mode_info_stride * (cm->mb_rows + 1) * sizeof(MODE_INFO)); + cm->mode_info_stride * (cm->mi_rows + 1) * sizeof(MODE_INFO)); vp9_update_mode_info_border(cm, cm->mip); cm->mi = cm->mip + cm->mode_info_stride + 1; @@ -1434,16 +1435,17 @@ VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) { cpi->gold_is_alt = 0; // Create the encoder segmentation map and set all entries to 0 - CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1)); + CHECK_MEM_ERROR(cpi->segmentation_map, + vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols, 1)); // And a copy in common for temporal coding CHECK_MEM_ERROR(cm->last_frame_seg_map, - vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1)); + vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols, 1)); // And a place holder structure is the coding context // for use if we want to save and restore it CHECK_MEM_ERROR(cpi->coding_context.last_frame_seg_map_copy, - vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1)); + vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols, 1)); CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1)); vpx_memset(cpi->active_map, 1, (cpi->common.mb_rows * cpi->common.mb_cols)); @@ -3336,6 +3338,7 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi, vp9_adapt_zpc_probs(&cpi->common); #endif } + if (cpi->common.frame_type != KEY_FRAME) { vp9_copy(cpi->common.fc.sb_ymode_counts, cpi->sb_ymode_count); vp9_copy(cpi->common.fc.ymode_counts, cpi->ymode_count); @@ -3668,10 +3671,12 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi, if (cm->show_frame) { vpx_memcpy(cm->prev_mip, cm->mip, - cm->mode_info_stride * (cm->mb_rows + 1) * sizeof(MODE_INFO)); + cm->mode_info_stride * (cm->mi_rows + 1) * + sizeof(MODE_INFO)); } else { vpx_memset(cm->prev_mip, 0, - cm->mode_info_stride * (cm->mb_rows + 1) * sizeof(MODE_INFO)); + cm->mode_info_stride * (cm->mi_rows + 1) * + sizeof(MODE_INFO)); } } diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c index 7a419fb61..f59385232 100644 --- a/vp9/encoder/vp9_ratectrl.c +++ b/vp9/encoder/vp9_ratectrl.c @@ -159,7 +159,7 @@ void vp9_save_coding_context(VP9_COMP *cpi) { vp9_copy(cc->prob_comppred, cm->prob_comppred); vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy, - cm->last_frame_seg_map, (cm->mb_rows * cm->mb_cols)); + cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols)); vp9_copy(cc->last_ref_lf_deltas, xd->last_ref_lf_deltas); vp9_copy(cc->last_mode_lf_deltas, xd->last_mode_lf_deltas); @@ -221,7 +221,7 @@ void vp9_restore_coding_context(VP9_COMP *cpi) { vpx_memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy, - (cm->mb_rows * cm->mb_cols)); + (cm->mi_rows * cm->mi_cols)); vp9_copy(xd->last_ref_lf_deltas, cc->last_ref_lf_deltas); vp9_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas); diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c index 7de5bf786..058a2da9c 100644 --- a/vp9/encoder/vp9_rdopt.c +++ b/vp9/encoder/vp9_rdopt.c @@ -1606,7 +1606,7 @@ static int labels2mode( int_mv seg_mvs[MAX_REF_FRAMES - 1], int_mv *best_ref_mv, int_mv *second_best_ref_mv, - int *mvjcost, int *mvcost[2]) { + int *mvjcost, int *mvcost[2], VP9_COMP *cpi) { MACROBLOCKD *const xd = &x->e_mbd; MODE_INFO *const mic = xd->mode_info_context; MB_MODE_INFO * mbmi = &mic->mbmi; @@ -2167,7 +2167,7 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, rate = labels2mode(x, labels, i, this_mode, &mode_mv[this_mode], &second_mode_mv[this_mode], seg_mvs[i], bsi->ref_mv, bsi->second_ref_mv, x->nmvjointcost, - x->mvcost); + x->mvcost, cpi); // Trap vectors that reach beyond the UMV borders if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || @@ -2226,7 +2226,8 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected], &second_mode_mv[mode_selected], seg_mvs[i], - bsi->ref_mv, bsi->second_ref_mv, x->nmvjointcost, x->mvcost); + bsi->ref_mv, bsi->second_ref_mv, x->nmvjointcost, + x->mvcost, cpi); br += sbr; bd += sbd; @@ -2735,7 +2736,7 @@ static void store_coding_context(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx, static void setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x, int idx, MV_REFERENCE_FRAME frame_type, enum BlockSize block_size, - int mb_row, int mb_col, + int mi_row, int mi_col, int_mv frame_nearest_mv[MAX_REF_FRAMES], int_mv frame_near_mv[MAX_REF_FRAMES], int frame_mdcounts[4][4], @@ -2750,13 +2751,15 @@ static void setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x, // set up scaling factors scale[frame_type] = cpi->common.active_ref_scale[frame_type - 1]; scale[frame_type].x_offset_q4 = - (mb_col * 16 * scale[frame_type].x_num / scale[frame_type].x_den) & 0xf; + (mi_col * MI_SIZE * scale[frame_type].x_num / + scale[frame_type].x_den) & 0xf; scale[frame_type].y_offset_q4 = - (mb_row * 16 * scale[frame_type].y_num / scale[frame_type].y_den) & 0xf; + (mi_row * MI_SIZE * scale[frame_type].y_num / + scale[frame_type].y_den) & 0xf; // TODO(jkoleszar): Is the UV buffer ever used here? If so, need to make this // use the UV scaling factors. - setup_pred_block(&yv12_mb[frame_type], yv12, mb_row, mb_col, + setup_pred_block(&yv12_mb[frame_type], yv12, mi_row, mi_col, &scale[frame_type], &scale[frame_type]); // Gets an initial list of candidate vectors from neighbours and orders them @@ -2873,8 +2876,8 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, int_mv frame_mv[MB_MODE_COUNT] [MAX_REF_FRAMES], YV12_BUFFER_CONFIG *scaled_ref_frame, - int mb_row, int mb_col) { - const int bw = 1 << mb_width_log2(bsize), bh = 1 << mb_height_log2(bsize); + int mi_row, int mi_col) { + const int bw = 1 << mi_width_log2(bsize), bh = 1 << mi_height_log2(bsize); const enum BlockSize block_size = y_bsizet_to_block_size(bsize); const enum BlockSize uv_block_size = y_to_uv_block_size(block_size); VP9_COMMON *cm = &cpi->common; @@ -2939,7 +2942,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, for (i = 0; i < MAX_MB_PLANE; i++) backup_yv12[i] = xd->plane[i].pre[0]; - setup_pre_planes(xd, scaled_ref_frame, NULL, mb_row, mb_col, + setup_pre_planes(xd, scaled_ref_frame, NULL, mi_row, mi_col, NULL, NULL); } @@ -3075,7 +3078,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, unsigned int sse, var; int tmp_rate_y, tmp_rate_u, tmp_rate_v; int tmp_dist_y, tmp_dist_u, tmp_dist_v; - vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize); + vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize); var = cpi->fn_ptr[block_size].vf(x->plane[0].src.buf, x->plane[0].src.stride, xd->plane[0].dst.buf, @@ -3084,7 +3087,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, // Note our transform coeffs are 8 times an orthogonal transform. // Hence quantizer step is also 8 times. To get effective quantizer // we need to divide by 8 before sending to modeling function. - model_rd_from_var_lapndz(var, 16 * bw * 16 * bh, + model_rd_from_var_lapndz(var, MI_SIZE * bw * MI_SIZE * bh, xd->plane[0].dequant[1] >> 3, &tmp_rate_y, &tmp_dist_y); var = cpi->fn_ptr[uv_block_size].vf(x->plane[1].src.buf, @@ -3092,7 +3095,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, xd->plane[1].dst.buf, xd->plane[1].dst.stride, &sse); - model_rd_from_var_lapndz(var, 8 * bw * 8 * bh, + model_rd_from_var_lapndz(var, MI_UV_SIZE * bw * MI_UV_SIZE * bh, xd->plane[1].dequant[1] >> 3, &tmp_rate_u, &tmp_dist_u); var = cpi->fn_ptr[uv_block_size].vf(x->plane[2].src.buf, @@ -3100,7 +3103,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, xd->plane[2].dst.buf, xd->plane[1].dst.stride, &sse); - model_rd_from_var_lapndz(var, 8 * bw * 8 * bh, + model_rd_from_var_lapndz(var, MI_UV_SIZE * bw * MI_UV_SIZE * bh, xd->plane[2].dequant[1] >> 3, &tmp_rate_v, &tmp_dist_v); rd = RDCOST(x->rdmult, x->rddiv, @@ -3125,18 +3128,18 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, (cm->mcomp_filter_type != SWITCHABLE && cm->mcomp_filter_type == mbmi->interp_filter)) { int i; - for (i = 0; i < 16 * bh; ++i) - vpx_memcpy(tmp_ybuf + i * 16 * bw, + for (i = 0; i < MI_SIZE * bh; ++i) + vpx_memcpy(tmp_ybuf + i * MI_SIZE * bw, xd->plane[0].dst.buf + i * xd->plane[0].dst.stride, - sizeof(unsigned char) * 16 * bw); - for (i = 0; i < 8 * bh; ++i) - vpx_memcpy(tmp_ubuf + i * 8 * bw, + sizeof(unsigned char) * MI_SIZE * bw); + for (i = 0; i < MI_UV_SIZE * bh; ++i) + vpx_memcpy(tmp_ubuf + i * MI_UV_SIZE * bw, xd->plane[1].dst.buf + i * xd->plane[1].dst.stride, - sizeof(unsigned char) * 8 * bw); - for (i = 0; i < 8 * bh; ++i) - vpx_memcpy(tmp_vbuf + i * 8 * bw, + sizeof(unsigned char) * MI_UV_SIZE * bw); + for (i = 0; i < MI_UV_SIZE * bh; ++i) + vpx_memcpy(tmp_vbuf + i * MI_UV_SIZE * bw, xd->plane[2].dst.buf + i * xd->plane[1].dst.stride, - sizeof(unsigned char) * 8 * bw); + sizeof(unsigned char) * MI_UV_SIZE * bw); pred_exists = 1; } interpolating_intpel_seen |= @@ -3153,19 +3156,22 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, if (pred_exists) { // FIXME(rbultje): mb code still predicts into xd->predictor - for (i = 0; i < bh * 16; ++i) + for (i = 0; i < bh * MI_SIZE; ++i) vpx_memcpy(xd->plane[0].dst.buf + i * xd->plane[0].dst.stride, - tmp_ybuf + i * bw * 16, sizeof(unsigned char) * bw * 16); - for (i = 0; i < bh * 8; ++i) + tmp_ybuf + i * bw * MI_SIZE, + sizeof(unsigned char) * bw * MI_SIZE); + for (i = 0; i < bh * MI_UV_SIZE; ++i) vpx_memcpy(xd->plane[1].dst.buf + i * xd->plane[1].dst.stride, - tmp_ubuf + i * bw * 8, sizeof(unsigned char) * bw * 8); - for (i = 0; i < bh * 8; ++i) + tmp_ubuf + i * bw * MI_UV_SIZE, + sizeof(unsigned char) * bw * MI_UV_SIZE); + for (i = 0; i < bh * MI_UV_SIZE; ++i) vpx_memcpy(xd->plane[2].dst.buf + i * xd->plane[1].dst.stride, - tmp_vbuf + i * bw * 8, sizeof(unsigned char) * bw * 8); + tmp_vbuf + i * bw * MI_UV_SIZE, + sizeof(unsigned char) * bw * MI_UV_SIZE); } else { // Handles the special case when a filter that is not in the // switchable list (ex. bilinear, 6-tap) is indicated at the frame level - vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize); + vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize); } if (cpi->common.mcomp_filter_type == SWITCHABLE) { @@ -3276,7 +3282,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, } static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, - int mb_row, int mb_col, + int mi_row, int mi_col, int *returnrate, int *returndistortion, int64_t *returnintra) { static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, @@ -3363,21 +3369,21 @@ static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, if (cpi->ref_frame_flags & VP9_LAST_FLAG) { setup_buffer_inter(cpi, x, cpi->lst_fb_idx, - LAST_FRAME, BLOCK_16X16, mb_row, mb_col, + LAST_FRAME, BLOCK_16X16, mi_row, mi_col, frame_mv[NEARESTMV], frame_mv[NEARMV], frame_mdcounts, yv12_mb, scale_factor); } if (cpi->ref_frame_flags & VP9_GOLD_FLAG) { setup_buffer_inter(cpi, x, cpi->gld_fb_idx, - GOLDEN_FRAME, BLOCK_16X16, mb_row, mb_col, + GOLDEN_FRAME, BLOCK_16X16, mi_row, mi_col, frame_mv[NEARESTMV], frame_mv[NEARMV], frame_mdcounts, yv12_mb, scale_factor); } if (cpi->ref_frame_flags & VP9_ALT_FLAG) { setup_buffer_inter(cpi, x, cpi->alt_fb_idx, - ALTREF_FRAME, BLOCK_16X16, mb_row, mb_col, + ALTREF_FRAME, BLOCK_16X16, mi_row, mi_col, frame_mv[NEARESTMV], frame_mv[NEARMV], frame_mdcounts, yv12_mb, scale_factor); } @@ -3742,7 +3748,7 @@ static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, if (tmp_rd < best_yrd) { int uv_skippable; - vp9_build_inter_predictors_sbuv(&x->e_mbd, mb_row, mb_col, + vp9_build_inter_predictors_sbuv(&x->e_mbd, mi_row, mi_col, BLOCK_SIZE_MB16X16); vp9_subtract_sbuv(x, BLOCK_SIZE_MB16X16); @@ -3791,7 +3797,7 @@ static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, &rate_uv, &distortion_uv, &mode_excluded, &disable_skip, mode_index, &tmp_best_filter, frame_mv, - scaled_ref_frame, mb_row, mb_col); + scaled_ref_frame, mi_row, mi_col); if (this_rd == INT64_MAX) continue; } @@ -4302,7 +4308,7 @@ void vp9_rd_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, } int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, - int mb_row, int mb_col, + int mi_row, int mi_col, int *returnrate, int *returndistortion, BLOCK_SIZE_TYPE bsize, @@ -4403,7 +4409,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { if (cpi->ref_frame_flags & flag_list[ref_frame]) { setup_buffer_inter(cpi, x, idx_list[ref_frame], ref_frame, block_size, - mb_row, mb_col, frame_mv[NEARESTMV], frame_mv[NEARMV], + mi_row, mi_col, frame_mv[NEARESTMV], frame_mv[NEARMV], frame_mdcounts, yv12_mb, scale_factor); } frame_mv[NEWMV][ref_frame].as_int = INVALID_MV; @@ -4603,7 +4609,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, &rate_uv, &distortion_uv, &mode_excluded, &disable_skip, mode_index, &tmp_best_filter, frame_mv, - scaled_ref_frame, mb_row, mb_col); + scaled_ref_frame, mi_row, mi_col); if (this_rd == INT64_MAX) continue; } @@ -4898,7 +4904,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, } void vp9_pick_mode_inter_macroblock(VP9_COMP *cpi, MACROBLOCK *x, - int mb_row, int mb_col, + int mi_row, int mi_col, int *totalrate, int *totaldist) { MACROBLOCKD *const xd = &x->e_mbd; MB_MODE_INFO * mbmi = &x->e_mbd.mode_info_context->mbmi; @@ -4916,7 +4922,7 @@ void vp9_pick_mode_inter_macroblock(VP9_COMP *cpi, MACROBLOCK *x, { int zbin_mode_boost_enabled = cpi->zbin_mode_boost_enabled; - rd_pick_inter_mode(cpi, x, mb_row, mb_col, &rate, + rd_pick_inter_mode(cpi, x, mi_row, mi_col, &rate, &distortion, &intra_error); /* restore cpi->zbin_mode_boost_enabled */ diff --git a/vp9/encoder/vp9_rdopt.h b/vp9/encoder/vp9_rdopt.h index 6fce5070d..eef2a4fe9 100644 --- a/vp9/encoder/vp9_rdopt.h +++ b/vp9/encoder/vp9_rdopt.h @@ -27,11 +27,11 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx); void vp9_pick_mode_inter_macroblock(VP9_COMP *cpi, MACROBLOCK *x, - int mb_row, int mb_col, + int mi_row, int mi_col, int *r, int *d); int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, - int mb_row, int mb_col, + int mi_row, int mi_col, int *r, int *d, BLOCK_SIZE_TYPE bsize, PICK_MODE_CONTEXT *ctx); diff --git a/vp9/encoder/vp9_segmentation.c b/vp9/encoder/vp9_segmentation.c index c243458f3..bee39cd80 100644 --- a/vp9/encoder/vp9_segmentation.c +++ b/vp9/encoder/vp9_segmentation.c @@ -37,7 +37,7 @@ void vp9_set_segmentation_map(VP9_PTR ptr, // Copy in the new segmentation map vpx_memcpy(cpi->segmentation_map, segmentation_map, - (cpi->common.mb_rows * cpi->common.mb_cols)); + (cpi->common.mi_rows * cpi->common.mi_cols)); // Signal that the map should be updated. cpi->mb.e_mbd.update_mb_segmentation_map = 1; @@ -127,13 +127,13 @@ static void count_segs(VP9_COMP *cpi, int *no_pred_segcounts, int (*temporal_predictor_count)[2], int *t_unpred_seg_counts, - int bw, int bh, int mb_row, int mb_col) { + int bw, int bh, int mi_row, int mi_col) { VP9_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->mb.e_mbd; const int segment_id = mi->mbmi.segment_id; xd->mode_info_context = mi; - set_mb_row_col(cm, xd, mb_row, bh, mb_col, bw); + set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw); // Count the number of hits on each segment with no prediction no_pred_segcounts[segment_id]++; @@ -141,8 +141,8 @@ static void count_segs(VP9_COMP *cpi, // Temporal prediction not allowed on key frames if (cm->frame_type != KEY_FRAME) { // Test to see if the segment id matches the predicted value. - const int pred_seg_id = vp9_get_pred_mb_segid(cm, mi->mbmi.sb_type, - mb_row, mb_col); + const int pred_seg_id = vp9_get_pred_mi_segid(cm, mi->mbmi.sb_type, + mi_row, mi_col); const int seg_predicted = (segment_id == pred_seg_id); // Get the segment id prediction context @@ -167,7 +167,7 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) { int t_pred_cost = INT_MAX; int i; - int tile_col, mb_row, mb_col; + int tile_col, mi_row, mi_col; int temporal_predictor_count[PREDICTION_PROBS][2]; int no_pred_segcounts[MAX_MB_SEGMENTS]; @@ -196,78 +196,95 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) { for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) { vp9_get_tile_col_offsets(cm, tile_col); - mi_ptr = cm->mi + cm->cur_tile_mb_col_start; - for (mb_row = 0; mb_row < cm->mb_rows; mb_row += 4, mi_ptr += 4 * mis) { + mi_ptr = cm->mi + cm->cur_tile_mi_col_start; + for (mi_row = 0; mi_row < cm->mi_rows; + mi_row += (4 << CONFIG_SB8X8), mi_ptr += (4 << CONFIG_SB8X8) * mis) { mi = mi_ptr; - for (mb_col = cm->cur_tile_mb_col_start; - mb_col < cm->cur_tile_mb_col_end; mb_col += 4, mi += 4) { + for (mi_col = cm->cur_tile_mi_col_start; + mi_col < cm->cur_tile_mi_col_end; + mi_col += (4 << CONFIG_SB8X8), mi += (4 << CONFIG_SB8X8)) { if (mi->mbmi.sb_type == BLOCK_SIZE_SB64X64) { count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 4, 4, mb_row, mb_col); + t_unpred_seg_counts, 4 << CONFIG_SB8X8, + 4 << CONFIG_SB8X8, mi_row, mi_col); } else if (mi->mbmi.sb_type == BLOCK_SIZE_SB64X32) { count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 4, 2, mb_row, mb_col); - if (mb_row + 2 != cm->mb_rows) - count_segs(cpi, mi + 2 * mis, no_pred_segcounts, + t_unpred_seg_counts, 4 << CONFIG_SB8X8, + 2 << CONFIG_SB8X8, mi_row, mi_col); + if (mi_row + (2 << CONFIG_SB8X8) != cm->mi_rows) + count_segs(cpi, mi + (2 << CONFIG_SB8X8) * mis, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 4, 2, mb_row + 2, mb_col); + t_unpred_seg_counts, 4 << CONFIG_SB8X8, + 2 << CONFIG_SB8X8, mi_row + (2 << CONFIG_SB8X8), mi_col); } else if (mi->mbmi.sb_type == BLOCK_SIZE_SB32X64) { count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 2, 4, mb_row, mb_col); - if (mb_col + 2 != cm->mb_cols) - count_segs(cpi, mi + 2, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 2, 4, mb_row, mb_col + 2); + t_unpred_seg_counts, 2 << CONFIG_SB8X8, + 4 << CONFIG_SB8X8, mi_row, mi_col); + if (mi_col + (2 << CONFIG_SB8X8) != cm->mi_cols) + count_segs(cpi, mi + (2 << CONFIG_SB8X8), no_pred_segcounts, + temporal_predictor_count, + t_unpred_seg_counts, 2 << CONFIG_SB8X8, + 4 << CONFIG_SB8X8, mi_row, mi_col + (2 << CONFIG_SB8X8)); } else { for (i = 0; i < 4; i++) { - int x_idx = (i & 1) << 1, y_idx = i & 2; + const int x_idx = (i & 1) << (1 + CONFIG_SB8X8); + const int y_idx = (i & 2) << CONFIG_SB8X8; MODE_INFO *sb_mi = mi + y_idx * mis + x_idx; - if (mb_col + x_idx >= cm->mb_cols || - mb_row + y_idx >= cm->mb_rows) { + if (mi_col + x_idx >= cm->mi_cols || + mi_row + y_idx >= cm->mi_rows) { continue; } if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB32X32) { count_segs(cpi, sb_mi, no_pred_segcounts, - temporal_predictor_count, t_unpred_seg_counts, 2, 2, - mb_row + y_idx, mb_col + x_idx); + temporal_predictor_count, t_unpred_seg_counts, + 2 << CONFIG_SB8X8, 2 << CONFIG_SB8X8, + mi_row + y_idx, mi_col + x_idx); } else if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB32X16) { count_segs(cpi, sb_mi, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 2, 1, - mb_row + y_idx, mb_col + x_idx); - if (mb_row + y_idx + 1 != cm->mb_rows) - count_segs(cpi, sb_mi + mis, no_pred_segcounts, - temporal_predictor_count, - t_unpred_seg_counts, 2, 1, - mb_row + y_idx + 1, mb_col + x_idx); + t_unpred_seg_counts, 2 << CONFIG_SB8X8, + 1 << CONFIG_SB8X8, + mi_row + y_idx, mi_col + x_idx); + if (mi_row + y_idx + (1 << CONFIG_SB8X8) != cm->mi_rows) + count_segs(cpi, sb_mi + (mis << CONFIG_SB8X8), + no_pred_segcounts, temporal_predictor_count, + t_unpred_seg_counts, 2 << CONFIG_SB8X8, + 1 << CONFIG_SB8X8, + mi_row + y_idx + (1 << CONFIG_SB8X8), + mi_col + x_idx); } else if (sb_mi->mbmi.sb_type == BLOCK_SIZE_SB16X32) { count_segs(cpi, sb_mi, no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 1, 2, - mb_row + y_idx, mb_col + x_idx); - if (mb_col + x_idx + 1 != cm->mb_cols) - count_segs(cpi, sb_mi + 1, no_pred_segcounts, + t_unpred_seg_counts, 1 << CONFIG_SB8X8, + 2 << CONFIG_SB8X8, + mi_row + y_idx, mi_col + x_idx); + if (mi_col + x_idx + (1 << CONFIG_SB8X8) != cm->mi_cols) + count_segs(cpi, sb_mi + (1 << CONFIG_SB8X8), no_pred_segcounts, temporal_predictor_count, - t_unpred_seg_counts, 1, 2, - mb_row + y_idx, mb_col + x_idx + 1); + t_unpred_seg_counts, 1 << CONFIG_SB8X8, + 2 << CONFIG_SB8X8, + mi_row + y_idx, + mi_col + x_idx + (1 << CONFIG_SB8X8)); } else { int j; for (j = 0; j < 4; j++) { - const int x_idx_mb = x_idx + (j & 1); - const int y_idx_mb = y_idx + (j >> 1); + const int x_idx_mb = x_idx + ((j & 1) << CONFIG_SB8X8); + const int y_idx_mb = y_idx + ((j >> 1) << CONFIG_SB8X8); MODE_INFO *mb_mi = mi + x_idx_mb + y_idx_mb * mis; - if (mb_col + x_idx_mb >= cm->mb_cols || - mb_row + y_idx_mb >= cm->mb_rows) { + if (mi_col + x_idx_mb >= cm->mi_cols || + mi_row + y_idx_mb >= cm->mi_rows) { continue; } assert(mb_mi->mbmi.sb_type == BLOCK_SIZE_MB16X16); count_segs(cpi, mb_mi, no_pred_segcounts, temporal_predictor_count, t_unpred_seg_counts, - 1, 1, mb_row + y_idx_mb, mb_col + x_idx_mb); + 1 << CONFIG_SB8X8, 1 << CONFIG_SB8X8, + mi_row + y_idx_mb, mi_col + x_idx_mb); } } } |