summaryrefslogtreecommitdiff
path: root/vp9/encoder
diff options
context:
space:
mode:
Diffstat (limited to 'vp9/encoder')
-rw-r--r--vp9/encoder/vp9_bitstream.c10
-rw-r--r--vp9/encoder/vp9_encodeframe.c597
-rw-r--r--vp9/encoder/vp9_encodeintra.c23
-rw-r--r--vp9/encoder/vp9_encodeintra.h2
-rw-r--r--vp9/encoder/vp9_encodemb.c161
-rw-r--r--vp9/encoder/vp9_onyx_if.c23
-rw-r--r--vp9/encoder/vp9_quantize.c6
-rw-r--r--vp9/encoder/vp9_ratectrl.c5
-rw-r--r--vp9/encoder/vp9_rdopt.c346
-rw-r--r--vp9/encoder/vp9_segmentation.c144
-rw-r--r--vp9/encoder/vp9_tokenize.c286
-rw-r--r--vp9/encoder/vp9_tokenize.h2
-rw-r--r--vp9/encoder/vp9_variance_c.c8
13 files changed, 615 insertions, 998 deletions
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index 9b8b109da..3ab67cd8c 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -1946,7 +1946,7 @@ void vp9_pack_bitstream(VP9_COMP *cpi, unsigned char *dest,
}
if (!pc->error_resilient_mode) {
- vp9_write_bit(&header_bc, pc->refresh_entropy_probs);
+ vp9_write_bit(&header_bc, pc->refresh_frame_context);
vp9_write_bit(&header_bc, pc->frame_parallel_decoding_mode);
}
@@ -2228,6 +2228,14 @@ void vp9_pack_bitstream(VP9_COMP *cpi, unsigned char *dest,
}
update_mbintra_mode_probs(cpi, &header_bc);
+ for (i = 0; i < NUM_PARTITION_CONTEXTS; ++i) {
+ vp9_prob Pnew[PARTITION_TYPES - 1];
+ unsigned int bct[PARTITION_TYPES - 1][2];
+ update_mode(&header_bc, PARTITION_TYPES, vp9_partition_encodings,
+ vp9_partition_tree, Pnew, pc->fc.partition_prob[i], bct,
+ (unsigned int *)cpi->partition_count[i]);
+ }
+
vp9_write_nmv_probs(cpi, xd->allow_high_precision_mv, &header_bc);
}
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 8e524f4ba..d40c604a4 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -562,6 +562,15 @@ void vp9_setup_src_planes(MACROBLOCK *x,
x->e_mbd.plane[2].subsampling_y);
}
+static INLINE void set_partition_seg_context(VP9_COMP *cpi,
+ int mi_row, int mi_col) {
+ VP9_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &cpi->mb.e_mbd;
+
+ 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);
+}
+
static void set_offsets(VP9_COMP *cpi,
int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) {
MACROBLOCK *const x = &cpi->mb;
@@ -574,14 +583,18 @@ static void set_offsets(VP9_COMP *cpi,
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;
+ int i;
// entropy context structures
- xd->above_context = cm->above_context + mb_col;
- xd->left_context = cm->left_context + (mb_row & 3);
+ for (i = 0; i < MAX_MB_PLANE; i++) {
+ xd->plane[i].above_context = cm->above_context[i] +
+ (mi_col * 4 >> (CONFIG_SB8X8 + xd->plane[i].subsampling_x));
+ xd->plane[i].left_context = cm->left_context[i] +
+ (((mi_row * 4 >> CONFIG_SB8X8) & 15) >> xd->plane[i].subsampling_y);
+ }
// partition contexts
- xd->above_seg_context = cm->above_seg_context + mb_col;
- xd->left_seg_context = cm->left_seg_context + (mb_row & 3);
+ set_partition_seg_context(cpi, mi_row, mi_col);
// Activity map pointer
x->mb_activity_ptr = &cpi->mb_activity_map[idx_map];
@@ -773,203 +786,134 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) {
}
}
-static void encode_sb(VP9_COMP *cpi,
- int mi_row,
- int mi_col,
- int output_enabled,
- TOKENEXTRA **tp, BLOCK_SIZE_TYPE is_sb) {
- VP9_COMMON *const cm = &cpi->common;
- MACROBLOCK *const x = &cpi->mb;
- MACROBLOCKD *const xd = &x->e_mbd;
- BLOCK_SIZE_TYPE bsize = BLOCK_SIZE_SB32X32;
- int pl;
-
- 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, mi_row, mi_col, bsize);
- update_state(cpi, &x->sb32_context[xd->sb_index],
- bsize, output_enabled);
-
- encode_superblock(cpi, tp,
- output_enabled, mi_row, mi_col, bsize);
- if (output_enabled) {
- update_stats(cpi, mi_row, mi_col);
- cpi->partition_count[pl][PARTITION_NONE]++;
-
- (*tp)->token = EOSB_TOKEN;
- (*tp)++;
- }
- } else if (is_sb == BLOCK_SIZE_SB16X32) {
- int i;
-
- if (output_enabled)
- cpi->partition_count[pl][PARTITION_VERT]++;
- 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, mi_row, mi_col + (i << CONFIG_SB8X8),
- BLOCK_SIZE_SB16X32);
- if (output_enabled) {
- update_stats(cpi, mi_row, mi_col + i);
-
- (*tp)->token = EOSB_TOKEN;
- (*tp)++;
- }
- }
- } else if (is_sb == BLOCK_SIZE_SB32X16) {
- int i;
-
- if (output_enabled)
- cpi->partition_count[pl][PARTITION_HORZ]++;
- 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, mi_row + (i << CONFIG_SB8X8), mi_col,
- BLOCK_SIZE_SB32X16);
- if (output_enabled) {
- update_stats(cpi, mi_row + (i << CONFIG_SB8X8), mi_col);
-
- (*tp)->token = EOSB_TOKEN;
- (*tp)++;
- }
- }
+static void set_block_index(MACROBLOCKD *xd, int idx,
+ BLOCK_SIZE_TYPE bsize) {
+ if (bsize >= BLOCK_SIZE_SB32X32) {
+ xd->sb_index = idx;
} else {
- int i;
- if (output_enabled)
- cpi->partition_count[pl][PARTITION_SPLIT]++;
+#if CONFIG_SB8X8
+ assert(bsize >= BLOCK_SIZE_MB16X16);
+#endif
+ xd->mb_index = idx;
+ }
+}
- for (i = 0; i < 4; i++) {
- const int x_idx = (i & 1) << CONFIG_SB8X8;
- const int y_idx = (i >> 1) << CONFIG_SB8X8;
+static PICK_MODE_CONTEXT *get_block_context(MACROBLOCK *x,
+ BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
- if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols)) {
- // MB lies outside frame, move on
- continue;
- }
+ switch (bsize) {
+ case BLOCK_SIZE_SB64X64:
+ return &x->sb64_context;
+ case BLOCK_SIZE_SB64X32:
+ return &x->sb64x32_context[xd->sb_index];
+ case BLOCK_SIZE_SB32X64:
+ return &x->sb32x64_context[xd->sb_index];
+ case BLOCK_SIZE_SB32X32:
+ return &x->sb32_context[xd->sb_index];
+ case BLOCK_SIZE_SB32X16:
+ return &x->sb32x16_context[xd->sb_index][xd->mb_index];
+ case BLOCK_SIZE_SB16X32:
+ return &x->sb16x32_context[xd->sb_index][xd->mb_index];
+ case BLOCK_SIZE_MB16X16:
+ return &x->mb_context[xd->sb_index][xd->mb_index];
+ default:
+ assert(0);
+ return NULL;
+ }
+}
- 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);
+static void encode_b(VP9_COMP *cpi, TOKENEXTRA **tp,
+ int mi_row, int mi_col, int output_enabled,
+ BLOCK_SIZE_TYPE bsize, int sub_index) {
+ VP9_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &cpi->mb;
+ MACROBLOCKD *const xd = &x->e_mbd;
- if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
- vp9_activity_masking(cpi, x);
+ if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
- encode_macroblock(cpi, tp,
- output_enabled, mi_row + y_idx, mi_col + x_idx);
- if (output_enabled) {
- update_stats(cpi, mi_row + y_idx, mi_col + x_idx);
+ if (sub_index != -1)
+ set_block_index(xd, sub_index, bsize);
+ set_offsets(cpi, mi_row, mi_col, bsize);
+ update_state(cpi, get_block_context(x, bsize), bsize, output_enabled);
+ if (bsize == BLOCK_SIZE_MB16X16) {
+ if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
+ vp9_activity_masking(cpi, x);
- (*tp)->token = EOSB_TOKEN;
- (*tp)++;
- }
- }
+ encode_macroblock(cpi, tp, output_enabled, mi_row, mi_col);
+ } else {
+ encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
}
- 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);
+ if (output_enabled) {
+ update_stats(cpi, mi_row, mi_col);
- // debug output
-#if DBG_PRNT_SEGMAP
- {
- FILE *statsfile;
- statsfile = fopen("segmap2.stt", "a");
- fprintf(statsfile, "\n");
- fclose(statsfile);
+ (*tp)->token = EOSB_TOKEN;
+ (*tp)++;
}
-#endif
}
-static void encode_sb64(VP9_COMP *cpi,
- int mi_row,
- int mi_col,
- TOKENEXTRA **tp, BLOCK_SIZE_TYPE is_sb[4]) {
+static void encode_sb(VP9_COMP *cpi, TOKENEXTRA **tp,
+ int mi_row, int mi_col, int output_enabled,
+ BLOCK_SIZE_TYPE level,
+ BLOCK_SIZE_TYPE c1, BLOCK_SIZE_TYPE c2[4]) {
VP9_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->mb;
MACROBLOCKD *const xd = &x->e_mbd;
- BLOCK_SIZE_TYPE bsize = BLOCK_SIZE_SB64X64;
+ const int bsl = mi_width_log2(level), bs = 1 << (bsl - 1);
+ const int bwl = mi_width_log2(c1), bhl = mi_height_log2(c1);
int pl;
- 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 (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
- if (is_sb[0] == BLOCK_SIZE_SB64X64) {
- set_offsets(cpi, mi_row, mi_col, bsize);
- update_state(cpi, &x->sb64_context, bsize, 1);
- encode_superblock(cpi, tp,
- 1, mi_row, mi_col, bsize);
- update_stats(cpi, mi_row, mi_col);
+ set_partition_seg_context(cpi, mi_row, mi_col);
+ pl = partition_plane_context(xd, level);
- (*tp)->token = EOSB_TOKEN;
- (*tp)++;
- cpi->partition_count[pl][PARTITION_NONE]++;
- } else if (is_sb[0] == BLOCK_SIZE_SB32X64) {
+ if (bsl == bwl && bsl == bhl) {
+ if (output_enabled && level > BLOCK_SIZE_MB16X16)
+ cpi->partition_count[pl][PARTITION_NONE]++;
+ encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, -1);
+ } else if (bsl == bhl && bsl > bwl) {
+ if (output_enabled)
+ cpi->partition_count[pl][PARTITION_VERT]++;
+ encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
+ encode_b(cpi, tp, mi_row, mi_col + bs, output_enabled, c1, 1);
+ } else if (bsl == bwl && bsl > bhl) {
+ if (output_enabled)
+ cpi->partition_count[pl][PARTITION_HORZ]++;
+ encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
+ encode_b(cpi, tp, mi_row + bs, mi_col, output_enabled, c1, 1);
+ } else {
+ BLOCK_SIZE_TYPE subsize;
int i;
- cpi->partition_count[pl][PARTITION_VERT]++;
- 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, 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)++;
+ assert(bwl < bsl && bhl < bsl);
+ if (level == BLOCK_SIZE_SB64X64) {
+ subsize = BLOCK_SIZE_SB32X32;
+ } else {
+ assert(level == BLOCK_SIZE_SB32X32);
+ subsize = BLOCK_SIZE_MB16X16;
}
- } else if (is_sb[0] == BLOCK_SIZE_SB64X32) {
- int i;
- cpi->partition_count[pl][PARTITION_HORZ]++;
- 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, 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)++;
- }
- } else {
- int i;
- cpi->partition_count[pl][PARTITION_SPLIT]++;
+ if (output_enabled)
+ cpi->partition_count[pl][PARTITION_SPLIT]++;
+
for (i = 0; i < 4; i++) {
- const int x_idx = (i & 1) << (1 + CONFIG_SB8X8);
- const int y_idx = (i & 2) << CONFIG_SB8X8;
+ const int x_idx = i & 1, y_idx = i >> 1;
- 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, mi_row + y_idx, mi_col + x_idx, 1, tp,
- is_sb[i]);
+ set_block_index(xd, i, subsize);
+ encode_sb(cpi, tp, mi_row + y_idx * bs, mi_col + x_idx * bs,
+ output_enabled, subsize,
+ subsize == BLOCK_SIZE_MB16X16 ? c1 : c2[i], c2);
}
}
- if (is_sb[0] > BLOCK_SIZE_SB32X32) {
- 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);
+ if (level > BLOCK_SIZE_MB16X16 &&
+ (level == BLOCK_SIZE_SB32X32 || bsl == bwl || bsl == bhl)) {
+ set_partition_seg_context(cpi, mi_row, mi_col);
+ update_partition_context(xd, c1, level);
}
}
@@ -983,22 +927,27 @@ static void encode_sb_row(VP9_COMP *cpi,
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_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 (mi_col = cm->cur_tile_mi_col_start;
mi_col < cm->cur_tile_mi_col_end; mi_col += (4 << CONFIG_SB8X8)) {
- int i;
+ int i, p;
BLOCK_SIZE_TYPE sb_partitioning[4];
int sb64_rate = 0, sb64_dist = 0;
int sb64_skip = 0;
- ENTROPY_CONTEXT_PLANES l[4], a[4];
+ ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
PARTITION_CONTEXT seg_l[4], seg_a[4];
TOKENEXTRA *tp_orig = *tp;
- memcpy(&a, cm->above_context + (mi_col >> CONFIG_SB8X8), sizeof(a));
- memcpy(&l, cm->left_context, sizeof(l));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ memcpy(a + 16 * p, cm->above_context[p] +
+ (mi_col * 4 >> (CONFIG_SB8X8 + xd->plane[p].subsampling_x)),
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_x);
+ memcpy(l + 16 * p, cm->left_context[p],
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_y);
+ }
memcpy(&seg_a, cm->above_seg_context + (mi_col >> CONFIG_SB8X8),
sizeof(seg_a));
memcpy(&seg_l, cm->left_seg_context, sizeof(seg_l));
@@ -1009,7 +958,7 @@ static void encode_sb_row(VP9_COMP *cpi,
int splitmodes_used = 0;
int sb32_skip = 0;
int j;
- ENTROPY_CONTEXT_PLANES l2[2], a2[2];
+ ENTROPY_CONTEXT l2[8 * MAX_MB_PLANE], a2[8 * MAX_MB_PLANE];
if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols)
continue;
@@ -1017,9 +966,18 @@ static void encode_sb_row(VP9_COMP *cpi,
xd->sb_index = i;
/* Function should not modify L & A contexts; save and restore on exit */
- 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));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ vpx_memcpy(l2 + 8 * p,
+ cm->left_context[p] +
+ (y_idx * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_y)),
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_y);
+ vpx_memcpy(a2 + 8 * p,
+ cm->above_context[p] +
+ ((mi_col + x_idx) * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_x)),
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_x);
+ }
/* Encode MBs in raster order within the SB */
sb_partitioning[i] = BLOCK_SIZE_MB16X16;
@@ -1052,13 +1010,20 @@ static void encode_sb_row(VP9_COMP *cpi,
}
/* Restore L & A coding context to those in place on entry */
- 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));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ vpx_memcpy(cm->left_context[p] +
+ (y_idx * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_y)),
+ l2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_y);
+ vpx_memcpy(cm->above_context[p] +
+ ((mi_col + x_idx) * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_x)),
+ a2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_x);
+ }
- 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);
+ set_partition_seg_context(cpi, mi_row + y_idx, mi_col + x_idx);
pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32);
sb32_rate += x->partition_cost[pl][PARTITION_SPLIT];
@@ -1091,9 +1056,7 @@ static void encode_sb_row(VP9_COMP *cpi,
d += d2;
}
- 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);
+ set_partition_seg_context(cpi, mi_row + y_idx, mi_col + x_idx);
pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32);
r += x->partition_cost[pl][PARTITION_HORZ];
@@ -1105,9 +1068,18 @@ static void encode_sb_row(VP9_COMP *cpi,
sb_partitioning[i] = BLOCK_SIZE_SB32X16;
}
- 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));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ vpx_memcpy(cm->left_context[p] +
+ (y_idx * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_y)),
+ l2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_y);
+ vpx_memcpy(cm->above_context[p] +
+ ((mi_col + x_idx) * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_x)),
+ a2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_x);
+ }
}
// check 16x32
@@ -1135,10 +1107,7 @@ static void encode_sb_row(VP9_COMP *cpi,
d += d2;
}
- 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);
+ set_partition_seg_context(cpi, mi_row + y_idx, mi_col + x_idx);
pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32);
r += x->partition_cost[pl][PARTITION_VERT];
@@ -1150,9 +1119,18 @@ static void encode_sb_row(VP9_COMP *cpi,
sb_partitioning[i] = BLOCK_SIZE_SB16X32;
}
- 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));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ vpx_memcpy(cm->left_context[p] +
+ (y_idx * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_y)),
+ l2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_y);
+ vpx_memcpy(cm->above_context[p] +
+ ((mi_col + x_idx) * 4 >> (CONFIG_SB8X8 +
+ xd->plane[p].subsampling_x)),
+ a2 + 8 * p,
+ sizeof(ENTROPY_CONTEXT) * 8 >> xd->plane[p].subsampling_x);
+ }
}
if (!sb32_skip &&
@@ -1165,9 +1143,7 @@ static void encode_sb_row(VP9_COMP *cpi,
tp, &r, &d, BLOCK_SIZE_SB32X32,
&x->sb32_context[xd->sb_index]);
- 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);
+ set_partition_seg_context(cpi, mi_row + y_idx, mi_col + x_idx);
pl = partition_plane_context(xd, BLOCK_SIZE_SB32X32);
r += x->partition_cost[pl][PARTITION_NONE];
@@ -1193,18 +1169,23 @@ 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, mi_row + y_idx, mi_col + x_idx, 0, tp,
- sb_partitioning[i]);
+ encode_sb(cpi, tp, mi_row + y_idx, mi_col + x_idx, 0,
+ BLOCK_SIZE_SB32X32, sb_partitioning[i], sb_partitioning);
}
- memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), &a, sizeof(a));
- memcpy(cm->left_context, &l, sizeof(l));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ memcpy(cm->above_context[p] +
+ (mi_col * 4 >> (CONFIG_SB8X8 + xd->plane[p].subsampling_x)),
+ a + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_x);
+ memcpy(cm->left_context[p], l + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_y);
+ }
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 + (mi_col >> CONFIG_SB8X8);
+ set_partition_seg_context(cpi, mi_row, mi_col);
pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64);
sb64_rate += x->partition_cost[pl][PARTITION_SPLIT];
@@ -1231,8 +1212,7 @@ static void encode_sb_row(VP9_COMP *cpi,
d += d2;
}
- xd->left_seg_context = cm->left_seg_context;
- xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8);
+ set_partition_seg_context(cpi, mi_row, mi_col);
pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64);
r += x->partition_cost[pl][PARTITION_HORZ];
@@ -1244,8 +1224,14 @@ static void encode_sb_row(VP9_COMP *cpi,
sb_partitioning[0] = BLOCK_SIZE_SB64X32;
}
- vpx_memcpy(cm->left_context, l, sizeof(l));
- vpx_memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), a, sizeof(a));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ memcpy(cm->above_context[p] +
+ (mi_col * 4 >> (CONFIG_SB8X8 + xd->plane[p].subsampling_x)),
+ a + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_x);
+ memcpy(cm->left_context[p], l + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_y);
+ }
}
// check 32x64
@@ -1271,8 +1257,7 @@ static void encode_sb_row(VP9_COMP *cpi,
d += d2;
}
- xd->left_seg_context = cm->left_seg_context;
- xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8);
+ set_partition_seg_context(cpi, mi_row, mi_col);
pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64);
r += x->partition_cost[pl][PARTITION_VERT];
@@ -1284,8 +1269,14 @@ static void encode_sb_row(VP9_COMP *cpi,
sb_partitioning[0] = BLOCK_SIZE_SB32X64;
}
- vpx_memcpy(cm->left_context, l, sizeof(l));
- vpx_memcpy(cm->above_context + (mi_col >> CONFIG_SB8X8), a, sizeof(a));
+ for (p = 0; p < MAX_MB_PLANE; p++) {
+ memcpy(cm->above_context[p] +
+ (mi_col * 4 >> (CONFIG_SB8X8 + xd->plane[p].subsampling_x)),
+ a + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_x);
+ memcpy(cm->left_context[p], l + 16 * p,
+ sizeof(ENTROPY_CONTEXT) * 16 >> xd->plane[p].subsampling_y);
+ }
}
if (!sb64_skip &&
@@ -1296,8 +1287,7 @@ static void encode_sb_row(VP9_COMP *cpi,
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 + (mi_col >> CONFIG_SB8X8);
+ set_partition_seg_context(cpi, mi_row, mi_col);
pl = partition_plane_context(xd, BLOCK_SIZE_SB64X64);
r += x->partition_cost[pl][PARTITION_NONE];
@@ -1310,7 +1300,8 @@ static void encode_sb_row(VP9_COMP *cpi,
}
assert(tp_orig == *tp);
- encode_sb64(cpi, mi_row, mi_col, tp, sb_partitioning);
+ encode_sb(cpi, tp, mi_row, mi_col, 1,
+ BLOCK_SIZE_SB64X64, sb_partitioning[0], sb_partitioning);
assert(tp_orig < *tp);
}
}
@@ -1368,8 +1359,10 @@ static void init_encode_frame_mb_context(VP9_COMP *cpi) {
vp9_zero(cpi->interintra_select_count);
#endif
- vpx_memset(cm->above_context, 0,
- sizeof(ENTROPY_CONTEXT_PLANES) * mb_cols_aligned_to_sb(cm));
+ // Note: this memset assumes above_context[0], [1] and [2]
+ // are allocated as part of the same buffer.
+ vpx_memset(cm->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 4 *
+ MAX_MB_PLANE * mb_cols_aligned_to_sb(cm));
vpx_memset(cm->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
mb_cols_aligned_to_sb(cm));
}
@@ -1564,19 +1557,22 @@ 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 mi_rows_left, int mi_cols_left,
- BLOCK_SIZE_TYPE bsize) {
+static void reset_skip_txfm_size_b(VP9_COMP *cpi, MODE_INFO *mi,
+ int mis, TX_SIZE txfm_max,
+ int bw, int bh, int mi_row, int mi_col,
+ BLOCK_SIZE_TYPE bsize) {
+ VP9_COMMON *const cm = &cpi->common;
MB_MODE_INFO *const mbmi = &mi->mbmi;
+ if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
+
if (mbmi->txfm_size > txfm_max) {
MACROBLOCK *const x = &cpi->mb;
MACROBLOCKD *const xd = &x->e_mbd;
const int segment_id = mbmi->segment_id;
- 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);
+ const int ymbs = MIN(bh, cm->mi_rows - mi_row);
+ const int xmbs = MIN(bw, cm->mi_cols - mi_col);
xd->mode_info_context = mi;
assert(vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP) ||
@@ -1585,6 +1581,56 @@ static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi,
}
}
+static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi,
+ TX_SIZE txfm_max,
+ int mi_row, int mi_col,
+ BLOCK_SIZE_TYPE bsize) {
+ VP9_COMMON *const cm = &cpi->common;
+ const int mis = cm->mode_info_stride;
+ int bwl, bhl;
+ const int bsl = mi_width_log2(bsize), bs = 1 << (bsl - 1);
+
+ if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
+
+ bwl = mi_width_log2(mi->mbmi.sb_type);
+ bhl = mi_height_log2(mi->mbmi.sb_type);
+
+ if (bwl == bsl && bhl == bsl) {
+ reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, 1 << bsl,
+ mi_row, mi_col, bsize);
+ } else if (bwl == bsl && bhl < bsl) {
+ reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, bs,
+ mi_row, mi_col, bsize);
+ reset_skip_txfm_size_b(cpi, mi + bs * mis, mis, txfm_max, 1 << bsl, bs,
+ mi_row + bs, mi_col, bsize);
+ } else if (bwl < bsl && bhl == bsl) {
+ reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, bs, 1 << bsl,
+ mi_row, mi_col, bsize);
+ reset_skip_txfm_size_b(cpi, mi + bs, mis, txfm_max, bs, 1 << bsl,
+ mi_row, mi_col + bs, bsize);
+ } else {
+ BLOCK_SIZE_TYPE subsize;
+ int n;
+
+ assert(bwl < bsl && bhl < bsl);
+ if (bsize == BLOCK_SIZE_SB64X64) {
+ subsize = BLOCK_SIZE_SB32X32;
+ } else {
+ assert(bsize == BLOCK_SIZE_SB32X32);
+ subsize = BLOCK_SIZE_MB16X16;
+ }
+
+ for (n = 0; n < 4; n++) {
+ const int y_idx = n >> 1, x_idx = n & 0x01;
+
+ reset_skip_txfm_size_sb(cpi, mi + y_idx * bs * mis + x_idx * bs,
+ txfm_max, mi_row + y_idx * bs,
+ mi_col + x_idx * bs, subsize);
+ }
+ }
+}
+
static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) {
VP9_COMMON *const cm = &cpi->common;
int mi_row, mi_col;
@@ -1596,92 +1642,8 @@ static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) {
mi = mi_ptr;
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->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->mi_rows - mi_row, cm->mi_cols - mi_col,
- BLOCK_SIZE_SB64X32);
- 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->mi_rows - mi_row, cm->mi_cols - mi_col,
- BLOCK_SIZE_SB32X64);
- 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 + CONFIG_SB8X8);
- const int y_idx_sb = (i & 2) << CONFIG_SB8X8;
- MODE_INFO *sb_mi = mi + y_idx_sb * mis + x_idx_sb;
-
- 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->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->mi_rows - mi_row - y_idx_sb,
- cm->mi_cols - mi_col - x_idx_sb,
- BLOCK_SIZE_SB32X16);
- 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->mi_rows - mi_row - y_idx_sb,
- cm->mi_cols - mi_col - x_idx_sb,
- BLOCK_SIZE_SB16X32);
- 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) << CONFIG_SB8X8);
- const int y_idx = y_idx_sb + ((m >> 1) << CONFIG_SB8X8);
- MODE_INFO *mb_mi;
-
- 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->mi_rows - mi_row - y_idx,
- cm->mi_cols - mi_col - x_idx,
- BLOCK_SIZE_MB16X16);
- }
- }
- }
- }
+ reset_skip_txfm_size_sb(cpi, mi, txfm_max,
+ mi_row, mi_col, BLOCK_SIZE_SB64X64);
}
}
}
@@ -1984,7 +1946,7 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t,
#endif
if (mbmi->mode == I4X4_PRED) {
vp9_encode_intra16x16mbuv(cm, x);
- vp9_encode_intra4x4mby(x);
+ vp9_encode_intra4x4mby(x, BLOCK_SIZE_MB16X16);
} else if (mbmi->mode == I8X8_PRED) {
vp9_encode_intra8x8mby(x);
vp9_encode_intra8x8mbuv(x);
@@ -2101,8 +2063,7 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t,
}
#endif
- vp9_tokenize_mb(cpi, xd, t, !output_enabled);
-
+ vp9_tokenize_sb(cpi, xd, t, !output_enabled, BLOCK_SIZE_MB16X16);
} else {
// FIXME(rbultje): not tile-aware (mi - 1)
int mb_skip_context =
diff --git a/vp9/encoder/vp9_encodeintra.c b/vp9/encoder/vp9_encodeintra.c
index 54c4f3635..f6ddca8f4 100644
--- a/vp9/encoder/vp9_encodeintra.c
+++ b/vp9/encoder/vp9_encodeintra.c
@@ -16,7 +16,7 @@
#include "vp9/common/vp9_invtrans.h"
#include "vp9/encoder/vp9_encodeintra.h"
-static void encode_intra4x4block(MACROBLOCK *x, int ib);
+static void encode_intra4x4block(MACROBLOCK *x, int ib, BLOCK_SIZE_TYPE bs);
int vp9_encode_intra(VP9_COMP *cpi, MACROBLOCK *x, int use_16x16_pred) {
MB_MODE_INFO * mbmi = &x->e_mbd.mode_info_context->mbmi;
@@ -33,27 +33,28 @@ int vp9_encode_intra(VP9_COMP *cpi, MACROBLOCK *x, int use_16x16_pred) {
for (i = 0; i < 16; i++) {
x->e_mbd.mode_info_context->bmi[i].as_mode.first = B_DC_PRED;
- encode_intra4x4block(x, i);
+ encode_intra4x4block(x, i, BLOCK_SIZE_MB16X16);
}
}
return vp9_get_mb_ss(x->plane[0].src_diff);
}
-static void encode_intra4x4block(MACROBLOCK *x, int ib) {
+static void encode_intra4x4block(MACROBLOCK *x, int ib,
+ BLOCK_SIZE_TYPE bsize) {
MACROBLOCKD * const xd = &x->e_mbd;
TX_TYPE tx_type;
uint8_t* const src =
- raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
+ raster_block_offset_uint8(xd, bsize, 0, ib,
x->plane[0].src.buf, x->plane[0].src.stride);
uint8_t* const dst =
- raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
+ raster_block_offset_uint8(xd, bsize, 0, ib,
xd->plane[0].dst.buf, xd->plane[0].dst.stride);
int16_t* const src_diff =
- raster_block_offset_int16(xd, BLOCK_SIZE_MB16X16, 0, ib,
+ raster_block_offset_int16(xd, bsize, 0, ib,
x->plane[0].src_diff);
int16_t* const diff =
- raster_block_offset_int16(xd, BLOCK_SIZE_MB16X16, 0, ib,
+ raster_block_offset_int16(xd, bsize, 0, ib,
xd->plane[0].diff);
int16_t* const coeff = BLOCK_OFFSET(x->plane[0].coeff, ib, 16);
@@ -88,11 +89,13 @@ static void encode_intra4x4block(MACROBLOCK *x, int ib) {
vp9_recon_b(dst, diff, dst, xd->plane[0].dst.stride);
}
-void vp9_encode_intra4x4mby(MACROBLOCK *mb) {
+void vp9_encode_intra4x4mby(MACROBLOCK *mb, BLOCK_SIZE_TYPE bsize) {
int i;
+ int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
+ int bc = 1 << (bwl + bhl);
- for (i = 0; i < 16; i++)
- encode_intra4x4block(mb, i);
+ for (i = 0; i < bc; i++)
+ encode_intra4x4block(mb, i, bsize);
}
void vp9_encode_intra16x16mby(VP9_COMMON *const cm, MACROBLOCK *x) {
diff --git a/vp9/encoder/vp9_encodeintra.h b/vp9/encoder/vp9_encodeintra.h
index 6576c94d2..7ec2f11d4 100644
--- a/vp9/encoder/vp9_encodeintra.h
+++ b/vp9/encoder/vp9_encodeintra.h
@@ -16,7 +16,7 @@
int vp9_encode_intra(VP9_COMP *cpi, MACROBLOCK *x, int use_16x16_pred);
void vp9_encode_intra16x16mby(VP9_COMMON *const cm, MACROBLOCK *x);
void vp9_encode_intra16x16mbuv(VP9_COMMON *const cm, MACROBLOCK *x);
-void vp9_encode_intra4x4mby(MACROBLOCK *mb);
+void vp9_encode_intra4x4mby(MACROBLOCK *mb, BLOCK_SIZE_TYPE bs);
void vp9_encode_intra8x8mby(MACROBLOCK *x);
void vp9_encode_intra8x8mbuv(MACROBLOCK *x);
void vp9_encode_intra8x8(MACROBLOCK *x, int ib);
diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c
index 0823316c9..0cb1ae958 100644
--- a/vp9/encoder/vp9_encodemb.c
+++ b/vp9/encoder/vp9_encodemb.c
@@ -486,25 +486,18 @@ static void optimize_b(VP9_COMMON *const cm,
void vp9_optimize_sby_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
+ ENTROPY_CONTEXT *a = xd->plane[0].above_context;
+ ENTROPY_CONTEXT *l = xd->plane[0].left_context;
const int bwl = b_width_log2(bsize) - 3, bw = 1 << bwl;
const int bh = 1 << (b_height_log2(bsize) - 3);
ENTROPY_CONTEXT ta[2], tl[2];
int n;
- for (n = 0; n < bw; n++) {
- ENTROPY_CONTEXT *a =
- (ENTROPY_CONTEXT *) (x->e_mbd.above_context + n * 2 + 0);
- ENTROPY_CONTEXT *a1 =
- (ENTROPY_CONTEXT *) (x->e_mbd.above_context + n * 2 + 1);
- ta[n] = (a[0] + a[1] + a[2] + a[3] + a1[0] + a1[1] + a1[2] + a1[3]) != 0;
- }
- for (n = 0; n < bh; n++) {
- ENTROPY_CONTEXT *l =
- (ENTROPY_CONTEXT *) (x->e_mbd.left_context + n * 2);
- ENTROPY_CONTEXT *l1 =
- (ENTROPY_CONTEXT *) (x->e_mbd.left_context + n * 2 + 1);
- tl[n] = (l[0] + l[1] + l[2] + l[3] + l1[0] + l1[1] + l1[2] + l1[3]) != 0;
- }
+ for (n = 0; n < bw; n++, a += 8)
+ ta[n] = (a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7]) != 0;
+ for (n = 0; n < bh; n++, l += 8)
+ tl[n] = (l[0] + l[1] + l[2] + l[3] + l[4] + l[5] + l[6] + l[7]) != 0;
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
@@ -516,19 +509,19 @@ void vp9_optimize_sby_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sby_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
+ ENTROPY_CONTEXT *a = xd->plane[0].above_context;
+ ENTROPY_CONTEXT *l = xd->plane[0].left_context;
const int bwl = b_width_log2(bsize) - 2, bw = 1 << bwl;
const int bh = 1 << (b_height_log2(bsize) - 2);
ENTROPY_CONTEXT ta[4], tl[4];
int n;
- for (n = 0; n < bw; n++) {
- ENTROPY_CONTEXT *a = (ENTROPY_CONTEXT *) (x->e_mbd.above_context + n);
+ for (n = 0; n < bw; n++, a += 4)
ta[n] = (a[0] + a[1] + a[2] + a[3]) != 0;
- }
- for (n = 0; n < bh; n++) {
- ENTROPY_CONTEXT *l = (ENTROPY_CONTEXT *) (x->e_mbd.left_context + n);
+ for (n = 0; n < bh; n++, l += 4)
tl[n] = (l[0] + l[1] + l[2] + l[3]) != 0;
- }
+
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
@@ -539,23 +532,18 @@ void vp9_optimize_sby_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sby_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
+ ENTROPY_CONTEXT *a = xd->plane[0].above_context;
+ ENTROPY_CONTEXT *l = xd->plane[0].left_context;
const int bwl = b_width_log2(bsize) - 1, bw = 1 << bwl;
const int bh = 1 << (b_height_log2(bsize) - 1);
ENTROPY_CONTEXT ta[8], tl[8];
int n;
- for (n = 0; n < bw; n += 2) {
- ENTROPY_CONTEXT *a =
- (ENTROPY_CONTEXT *) (x->e_mbd.above_context + (n >> 1));
- ta[n + 0] = (a[0] + a[1]) != 0;
- ta[n + 1] = (a[2] + a[3]) != 0;
- }
- for (n = 0; n < bh; n += 2) {
- ENTROPY_CONTEXT *l =
- (ENTROPY_CONTEXT *) (x->e_mbd.left_context + (n >> 1));
- tl[n + 0] = (l[0] + l[1]) != 0;
- tl[n + 1] = (l[2] + l[3]) != 0;
- }
+ for (n = 0; n < bw; n++, a += 2)
+ ta[n] = (a[0] + a[1]) != 0;
+ for (n = 0; n < bh; n++, l += 2)
+ tl[n] = (l[0] + l[1]) != 0;
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
@@ -567,17 +555,14 @@ void vp9_optimize_sby_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sby_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
int bwl = b_width_log2(bsize), bw = 1 << bwl;
int bh = 1 << b_height_log2(bsize);
ENTROPY_CONTEXT ta[16], tl[16];
int n;
- for (n = 0; n < bw; n += 4)
- vpx_memcpy(&ta[n], x->e_mbd.above_context + (n >> 2),
- sizeof(ENTROPY_CONTEXT) * 4);
- for (n = 0; n < bh; n += 4)
- vpx_memcpy(&tl[n], x->e_mbd.left_context + (n >> 2),
- sizeof(ENTROPY_CONTEXT) * 4);
+ vpx_memcpy(ta, xd->plane[0].above_context, sizeof(ENTROPY_CONTEXT) * bw);
+ vpx_memcpy(tl, xd->plane[0].left_context, sizeof(ENTROPY_CONTEXT) * bh);
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
@@ -589,24 +574,18 @@ void vp9_optimize_sby_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sbuv_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
- ENTROPY_CONTEXT *ta = (ENTROPY_CONTEXT *) x->e_mbd.above_context;
- ENTROPY_CONTEXT *tl = (ENTROPY_CONTEXT *) x->e_mbd.left_context;
- ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
+ MACROBLOCKD *const xd = &x->e_mbd;
int b;
assert(bsize == BLOCK_SIZE_SB64X64);
for (b = 256; b < 384; b += 64) {
const int plane = 1 + (b >= 320);
- a = ta + vp9_block2above_sb64[TX_32X32][b];
- l = tl + vp9_block2left_sb64[TX_32X32][b];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a2 = a + 2 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l2 = l + 2 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a3 = a + 3 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l3 = l + 3 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a_ec = (a[0] + a[1] + a1[0] + a1[1] + a2[0] + a2[1] + a3[0] + a3[1]) != 0;
- l_ec = (l[0] + l[1] + l1[0] + l1[1] + l2[0] + l2[1] + l3[0] + l3[1]) != 0;
+ ENTROPY_CONTEXT *a = xd->plane[plane].above_context;
+ ENTROPY_CONTEXT *l = xd->plane[plane].left_context;
+ ENTROPY_CONTEXT a_ec, l_ec;
+
+ a_ec = (a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7]) != 0;
+ l_ec = (l[0] + l[1] + l[2] + l[3] + l[4] + l[5] + l[6] + l[7]) != 0;
optimize_b(cm, x, b, PLANE_TYPE_UV, x->e_mbd.plane[plane].dequant,
&a_ec, &l_ec, TX_32X32, 256);
}
@@ -614,32 +593,27 @@ void vp9_optimize_sbuv_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sbuv_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
const int bwl = b_width_log2(bsize) - 2, bhl = b_height_log2(bsize) - 2;
const int bw = 1 << (bwl - 1);
const int bh = 1 << (bhl - 1);
int uvoff = 16 << (bwl + bhl);
- ENTROPY_CONTEXT ta[2][2], tl[2][2];
int plane, n;
- for (n = 0; n < bw; n++) {
- ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + n * 2;
- ENTROPY_CONTEXT_PLANES *a1 = x->e_mbd.above_context + n * 2 + 1;
- ta[0][n] = (a->u[0] + a->u[1] + a1->u[0] + a1->u[1]) != 0;
- ta[1][n] = (a->v[0] + a->v[1] + a1->v[0] + a1->v[1]) != 0;
- }
- for (n = 0; n < bh; n++) {
- ENTROPY_CONTEXT_PLANES *l = (x->e_mbd.left_context + n * 2);
- ENTROPY_CONTEXT_PLANES *l1 = (x->e_mbd.left_context + n * 2 + 1);
- tl[0][n] = (l->u[0] + l->u[1] + l1->u[0] + l1->u[1]) != 0;
- tl[1][n] = (l->v[0] + l->v[1] + l1->v[0] + l1->v[1]) != 0;
- }
+ for (plane = 1; plane < MAX_MB_PLANE; plane++) {
+ ENTROPY_CONTEXT ta[2], *a = xd->plane[plane].above_context;
+ ENTROPY_CONTEXT tl[2], *l = xd->plane[plane].left_context;
+
+ for (n = 0; n < bw; n++, a += 4)
+ ta[n] = (a[0] + a[1] + a[2] + a[3]) != 0;
+ for (n = 0; n < bh; n++, l += 4)
+ tl[n] = (l[0] + l[1] + l[2] + l[3]) != 0;
- for (plane = 0; plane < 2; plane++) {
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
optimize_b(cm, x, uvoff + n * 16, PLANE_TYPE_UV,
- x->e_mbd.plane[plane + 1].dequant,
- &ta[plane][x_idx], &tl[plane][y_idx],
+ x->e_mbd.plane[plane].dequant,
+ &ta[x_idx], &tl[y_idx],
TX_16X16, bh * bw * 64);
}
uvoff = (uvoff * 5) >> 2; // switch u -> v
@@ -648,30 +622,27 @@ void vp9_optimize_sbuv_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sbuv_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
const int bwl = b_width_log2(bsize) - 1, bhl = b_height_log2(bsize) - 1;
const int bw = 1 << (bwl - 1);
const int bh = 1 << (bhl - 1);
int uvoff = 4 << (bwl + bhl);
- ENTROPY_CONTEXT ta[2][4], tl[2][4];
int plane, n;
- for (n = 0; n < bw; n++) {
- ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + n;
- ta[0][n] = (a->u[0] + a->u[1]) != 0;
- ta[1][n] = (a->v[0] + a->v[1]) != 0;
- }
- for (n = 0; n < bh; n++) {
- ENTROPY_CONTEXT_PLANES *l = x->e_mbd.left_context + n;
- tl[0][n] = (l->u[0] + l->u[1]) != 0;
- tl[1][n] = (l->v[0] + l->v[1]) != 0;
- }
+ for (plane = 1; plane < MAX_MB_PLANE; plane++) {
+ ENTROPY_CONTEXT ta[4], *a = xd->plane[plane].above_context;
+ ENTROPY_CONTEXT tl[4], *l = xd->plane[plane].left_context;
+
+ for (n = 0; n < bw; n++, a += 2)
+ ta[n] = (a[0] + a[1]) != 0;
+ for (n = 0; n < bh; n++, l += 2)
+ tl[n] = (l[0] + l[1]) != 0;
- for (plane = 0; plane < 2; plane++) {
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
optimize_b(cm, x, uvoff + n * 4, PLANE_TYPE_UV,
- x->e_mbd.plane[plane + 1].dequant,
- &ta[plane][x_idx], &tl[plane][y_idx],
+ x->e_mbd.plane[plane].dequant,
+ &ta[x_idx], &tl[y_idx],
TX_8X8, bh * bw * 16);
}
uvoff = (uvoff * 5) >> 2; // switch u -> v
@@ -680,34 +651,26 @@ void vp9_optimize_sbuv_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
void vp9_optimize_sbuv_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
+ MACROBLOCKD *const xd = &x->e_mbd;
const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
const int bw = 1 << (bwl - 1);
const int bh = 1 << (bhl - 1);
int uvoff = 1 << (bwl + bhl);
- ENTROPY_CONTEXT ta[2][8], tl[2][8];
int plane, n;
- for (n = 0; n < bw; n += 2) {
- ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + (n >> 1);
- ta[0][n + 0] = (a->u[0]) != 0;
- ta[0][n + 1] = (a->u[1]) != 0;
- ta[1][n + 0] = (a->v[0]) != 0;
- ta[1][n + 1] = (a->v[1]) != 0;
- }
- for (n = 0; n < bh; n += 2) {
- ENTROPY_CONTEXT_PLANES *l = x->e_mbd.left_context + (n >> 1);
- tl[0][n + 0] = (l->u[0]) != 0;
- tl[0][n + 1] = (l->u[1]) != 0;
- tl[1][n + 0] = (l->v[0]) != 0;
- tl[1][n + 1] = (l->v[1]) != 0;
- }
+ for (plane = 1; plane < MAX_MB_PLANE; plane++) {
+ ENTROPY_CONTEXT ta[8], tl[8];
+
+ vpx_memcpy(ta, xd->plane[plane].above_context,
+ sizeof(ENTROPY_CONTEXT) * bw);
+ vpx_memcpy(tl, xd->plane[plane].left_context,
+ sizeof(ENTROPY_CONTEXT) * bh);
- for (plane = 0; plane < 2; plane++) {
for (n = 0; n < bw * bh; n++) {
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
optimize_b(cm, x, uvoff + n, PLANE_TYPE_UV,
- x->e_mbd.plane[plane + 1].dequant,
- &ta[plane][x_idx], &tl[plane][y_idx],
+ x->e_mbd.plane[plane].dequant,
+ &ta[x_idx], &tl[y_idx],
TX_4X4, bh * bw * 4);
}
uvoff = (uvoff * 5) >> 2; // switch u -> v
diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index d557c6e25..e14f59f5e 100644
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -523,8 +523,8 @@ static void configure_implicit_segmentation(VP9_COMP *cpi) {
xd->update_mb_segmentation_data = 1;
- // Enable use of q deltas on segments
- for (i = 0; i < MAX_MB_SEGMENTS; ++i) {
+ // Enable use of q deltas on segments 1 and up
+ for (i = 1; i < MAX_MB_SEGMENTS; ++i) {
qi_delta = compute_qdelta(cpi, cpi->active_worst_quality, q_target);
vp9_set_segdata(xd, i, SEG_LVL_ALT_Q, qi_delta);
q_target *= 0.95;
@@ -1207,7 +1207,7 @@ void vp9_change_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
// cpi->use_last_frame_only = 0;
cpi->refresh_golden_frame = 0;
cpi->refresh_last_frame = 1;
- cm->refresh_entropy_probs = 1;
+ cm->refresh_frame_context = 1;
setup_features(cpi);
cpi->mb.e_mbd.allow_high_precision_mv = 0; // Default mv precision adaptation
@@ -2137,10 +2137,7 @@ int vp9_set_reference_enc(VP9_PTR ptr, VP9_REFFRAME ref_frame_flag,
return 0;
}
int vp9_update_entropy(VP9_PTR comp, int update) {
- VP9_COMP *cpi = (VP9_COMP *) comp;
- VP9_COMMON *cm = &cpi->common;
- cm->refresh_entropy_probs = update;
-
+ ((VP9_COMP *)comp)->common.refresh_frame_context = update;
return 0;
}
@@ -2753,7 +2750,7 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi,
(cpi->oxcf.frame_parallel_decoding_mode != 0);
if (cm->error_resilient_mode) {
cm->frame_parallel_decoding_mode = 1;
- cm->refresh_entropy_probs = 0;
+ cm->refresh_frame_context = 0;
}
}
@@ -3735,7 +3732,7 @@ static int frame_is_reference(const VP9_COMP *cpi) {
cpi->refresh_last_frame ||
cpi->refresh_golden_frame ||
cpi->refresh_alt_ref_frame ||
- cm->refresh_entropy_probs ||
+ cm->refresh_frame_context ||
mb->mode_ref_lf_delta_update ||
mb->update_mb_segmentation_map ||
mb->update_mb_segmentation_data;
@@ -4005,17 +4002,15 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
encode_frame_to_data_rate(cpi, size, dest, frame_flags);
}
- if (cm->refresh_entropy_probs) {
- vpx_memcpy(&cm->frame_contexts[cm->frame_context_idx], &cm->fc,
- sizeof(cm->fc));
- }
+ if (cm->refresh_frame_context)
+ cm->frame_contexts[cm->frame_context_idx] = cm->fc;
if (*size > 0) {
// if its a dropped frame honor the requests on subsequent frames
cpi->droppable = !frame_is_reference(cpi);
// return to normal state
- cm->refresh_entropy_probs = 1;
+ cm->refresh_frame_context = 1;
cpi->refresh_alt_ref_frame = 0;
cpi->refresh_golden_frame = 0;
cpi->refresh_last_frame = 1;
diff --git a/vp9/encoder/vp9_quantize.c b/vp9/encoder/vp9_quantize.c
index ece131898..77e19721c 100644
--- a/vp9/encoder/vp9_quantize.c
+++ b/vp9/encoder/vp9_quantize.c
@@ -286,7 +286,7 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
cpi->common.y_dequant[q][0] = quant_val;
cpi->zrun_zbin_boost_y1[q][0] = (quant_val * zbin_boost[0]) >> 7;
- quant_val = vp9_dc_uv_quant(q, cpi->common.uv_dc_delta_q);
+ quant_val = vp9_dc_quant(q, cpi->common.uv_dc_delta_q);
invert_quant(cpi->UVquant[q] + 0, cpi->UVquant_shift[q] + 0, quant_val);
cpi->UVzbin[q][0] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
cpi->UVround[q][0] = (qrounding_factor * quant_val) >> 7;
@@ -297,7 +297,7 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
for (i = 1; i < 16; i++) {
int rc = vp9_default_zig_zag1d_4x4[i];
- quant_val = vp9_ac_yquant(q);
+ quant_val = vp9_ac_quant(q, 0);
invert_quant(cpi->Y1quant[q] + rc, cpi->Y1quant_shift[q] + rc, quant_val);
cpi->Y1zbin[q][rc] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
cpi->Y1round[q][rc] = (qrounding_factor * quant_val) >> 7;
@@ -305,7 +305,7 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
cpi->zrun_zbin_boost_y1[q][i] =
ROUND_POWER_OF_TWO(quant_val * zbin_boost[i], 7);
- quant_val = vp9_ac_uv_quant(q, cpi->common.uv_ac_delta_q);
+ quant_val = vp9_ac_quant(q, cpi->common.uv_ac_delta_q);
invert_quant(cpi->UVquant[q] + rc, cpi->UVquant_shift[q] + rc, quant_val);
cpi->UVzbin[q][rc] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
cpi->UVround[q][rc] = (qrounding_factor * quant_val) >> 7;
diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c
index f59385232..47252253d 100644
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -89,7 +89,7 @@ static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3,
// tables if and when things settle down in the experimental bitstream
double vp9_convert_qindex_to_q(int qindex) {
// Convert the index to a real Q value (scaled down to match old Q values)
- return vp9_ac_yquant(qindex) / 4.0;
+ return vp9_ac_quant(qindex, 0) / 4.0;
}
int vp9_gfboost_qadjust(int qindex) {
@@ -262,8 +262,7 @@ void vp9_setup_inter_frame(VP9_COMP *cpi) {
vp9_setup_past_independence(cm, xd);
assert(cm->frame_context_idx < NUM_FRAME_CONTEXTS);
- vpx_memcpy(&cm->fc, &cm->frame_contexts[cm->frame_context_idx],
- sizeof(cm->fc));
+ cm->fc = cm->frame_contexts[cm->frame_context_idx];
}
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index 058a2da9c..0e85a0c71 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -187,7 +187,7 @@ void vp9_init_me_luts() {
}
static int compute_rd_mult(int qindex) {
- int q = vp9_dc_quant(qindex, 0);
+ const int q = vp9_dc_quant(qindex, 0);
return (11 * q * q) >> 2;
}
@@ -292,8 +292,8 @@ int vp9_block_error_c(int16_t *coeff, int16_t *dqcoeff, int block_size) {
static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
int ib, PLANE_TYPE type,
- ENTROPY_CONTEXT *a,
- ENTROPY_CONTEXT *l,
+ ENTROPY_CONTEXT *A,
+ ENTROPY_CONTEXT *L,
TX_SIZE tx_size,
int y_blocks) {
MACROBLOCKD *const xd = &mb->e_mbd;
@@ -309,11 +309,7 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
const int ref = mbmi->ref_frame != INTRA_FRAME;
unsigned int (*token_costs)[PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS] =
mb->token_costs[tx_size][type][ref];
- ENTROPY_CONTEXT a_ec, l_ec;
- ENTROPY_CONTEXT *const a1 = a +
- sizeof(ENTROPY_CONTEXT_PLANES)/sizeof(ENTROPY_CONTEXT);
- ENTROPY_CONTEXT *const l1 = l +
- sizeof(ENTROPY_CONTEXT_PLANES)/sizeof(ENTROPY_CONTEXT);
+ ENTROPY_CONTEXT above_ec, left_ec;
TX_TYPE tx_type = DCT_DCT;
#if CONFIG_CODE_ZEROGROUP
@@ -348,8 +344,8 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
case TX_4X4: {
tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type_4x4(xd, ib) : DCT_DCT;
- a_ec = *a;
- l_ec = *l;
+ above_ec = A[0] != 0;
+ left_ec = L[0] != 0;
coef_probs = cm->fc.coef_probs_4x4;
seg_eob = 16;
scan = get_scan_4x4(tx_type);
@@ -364,8 +360,8 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
const int x = ib & ((1 << sz) - 1), y = ib - x;
TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type_8x8(xd, y + (x >> 1)) : DCT_DCT;
- a_ec = (a[0] + a[1]) != 0;
- l_ec = (l[0] + l[1]) != 0;
+ above_ec = (A[0] + A[1]) != 0;
+ left_ec = (L[0] + L[1]) != 0;
scan = get_scan_8x8(tx_type);
coef_probs = cm->fc.coef_probs_8x8;
seg_eob = 64;
@@ -383,13 +379,8 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
scan = get_scan_16x16(tx_type);
coef_probs = cm->fc.coef_probs_16x16;
seg_eob = 256;
- if (type == PLANE_TYPE_UV) {
- a_ec = (a[0] + a[1] + a1[0] + a1[1]) != 0;
- l_ec = (l[0] + l[1] + l1[0] + l1[1]) != 0;
- } else {
- a_ec = (a[0] + a[1] + a[2] + a[3]) != 0;
- l_ec = (l[0] + l[1] + l[2] + l[3]) != 0;
- }
+ above_ec = (A[0] + A[1] + A[2] + A[3]) != 0;
+ left_ec = (L[0] + L[1] + L[2] + L[3]) != 0;
#if CONFIG_CODE_ZEROGROUP
zpc_probs = &cm->fc.zpc_probs_16x16;
#endif
@@ -399,22 +390,9 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
scan = vp9_default_zig_zag1d_32x32;
coef_probs = cm->fc.coef_probs_32x32;
seg_eob = 1024;
- if (type == PLANE_TYPE_UV) {
- ENTROPY_CONTEXT *a2, *a3, *l2, *l3;
- a2 = a1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a3 = a2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l2 = l1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l3 = l2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a_ec = (a[0] + a[1] + a1[0] + a1[1] +
- a2[0] + a2[1] + a3[0] + a3[1]) != 0;
- l_ec = (l[0] + l[1] + l1[0] + l1[1] +
- l2[0] + l2[1] + l3[0] + l3[1]) != 0;
- } else {
- a_ec = (a[0] + a[1] + a[2] + a[3] +
- a1[0] + a1[1] + a1[2] + a1[3]) != 0;
- l_ec = (l[0] + l[1] + l[2] + l[3] +
- l1[0] + l1[1] + l1[2] + l1[3]) != 0;
- }
+ above_ec = (A[0] + A[1] + A[2] + A[3] + A[4] + A[5] + A[6] + A[7]) != 0;
+ left_ec = (L[0] + L[1] + L[2] + L[3] + L[4] + L[5] + L[6] + L[7]) != 0;
+
#if CONFIG_CODE_ZEROGROUP
zpc_probs = &cm->fc.zpc_probs_32x32;
#endif
@@ -425,7 +403,7 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
}
assert(eob <= seg_eob);
- pt = combine_entropy_contexts(a_ec, l_ec);
+ pt = combine_entropy_contexts(above_ec, left_ec);
nb = vp9_get_coef_neighbors_handle(scan, &pad);
default_eob = seg_eob;
@@ -534,23 +512,11 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb,
}
}
- // is eob first coefficient;
- pt = (c > 0);
- *a = *l = pt;
- if (tx_size >= TX_8X8) {
- a[1] = l[1] = pt;
- if (tx_size >= TX_16X16) {
- if (type == PLANE_TYPE_UV) {
- a1[0] = a1[1] = l1[0] = l1[1] = pt;
- } else {
- a[2] = a[3] = l[2] = l[3] = pt;
- if (tx_size >= TX_32X32) {
- a1[0] = a1[1] = a1[2] = a1[3] = pt;
- l1[0] = l1[1] = l1[2] = l1[3] = pt;
- }
- }
- }
+ // is eob first coefficient;
+ for (pt = 0; pt < (1 << tx_size); pt++) {
+ A[pt] = L[pt] = c > 0;
}
+
return cost;
}
@@ -670,19 +636,18 @@ static int rdcost_sby_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
const int bh = 1 << b_height_log2(bsize);
int cost = 0, b;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
+ ENTROPY_CONTEXT t_above[16], t_left[16];
- vpx_memcpy(&t_above, xd->above_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bw) >> 2);
- vpx_memcpy(&t_left, xd->left_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bh) >> 2);
+ vpx_memcpy(&t_above, xd->plane[0].above_context,
+ sizeof(ENTROPY_CONTEXT) * bw);
+ vpx_memcpy(&t_left, xd->plane[0].left_context,
+ sizeof(ENTROPY_CONTEXT) * bh);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, b, PLANE_TYPE_Y_WITH_DC,
- ((ENTROPY_CONTEXT *) &t_above[x_idx >> 2]) + (x_idx & 3),
- ((ENTROPY_CONTEXT *) &t_left[y_idx >> 2]) + (y_idx & 3),
- TX_4X4, bw * bh);
+ t_above + x_idx, t_left + y_idx,
+ TX_4X4, bw * bh);
}
return cost;
@@ -709,19 +674,18 @@ static int rdcost_sby_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
const int bh = 1 << (b_height_log2(bsize) - 1);
int cost = 0, b;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
+ ENTROPY_CONTEXT t_above[16], t_left[16];
- vpx_memcpy(&t_above, xd->above_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bw) >> 1);
- vpx_memcpy(&t_left, xd->left_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bh) >> 1);
+ vpx_memcpy(&t_above, xd->plane[0].above_context,
+ sizeof(ENTROPY_CONTEXT) * 2 * bw);
+ vpx_memcpy(&t_left, xd->plane[0].left_context,
+ sizeof(ENTROPY_CONTEXT) * 2 * bh);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, b * 4, PLANE_TYPE_Y_WITH_DC,
- ((ENTROPY_CONTEXT *) &t_above[x_idx >> 1]) + ((x_idx & 1) << 1),
- ((ENTROPY_CONTEXT *) &t_left[y_idx >> 1]) + ((y_idx & 1) << 1),
- TX_8X8, 4 * bw * bh);
+ t_above + x_idx * 2, t_left + y_idx * 2,
+ TX_8X8, 4 * bw * bh);
}
return cost;
@@ -748,16 +712,17 @@ static int rdcost_sby_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
const int bh = 1 << (b_height_log2(bsize) - 2);
int cost = 0, b;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
+ ENTROPY_CONTEXT t_above[16], t_left[16];
- vpx_memcpy(&t_above, xd->above_context, sizeof(ENTROPY_CONTEXT_PLANES) * bw);
- vpx_memcpy(&t_left, xd->left_context, sizeof(ENTROPY_CONTEXT_PLANES) * bh);
+ vpx_memcpy(&t_above, xd->plane[0].above_context,
+ sizeof(ENTROPY_CONTEXT) * 4 * bw);
+ vpx_memcpy(&t_left, xd->plane[0].left_context,
+ sizeof(ENTROPY_CONTEXT) * 4 * bh);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, b * 16, PLANE_TYPE_Y_WITH_DC,
- (ENTROPY_CONTEXT *) &t_above[x_idx],
- (ENTROPY_CONTEXT *) &t_left[y_idx],
+ t_above + x_idx * 4, t_left + y_idx * 4,
TX_16X16, bw * bh * 16);
}
@@ -785,18 +750,17 @@ static int rdcost_sby_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
const int bh = 1 << (b_height_log2(bsize) - 3);
int cost = 0, b;
MACROBLOCKD * const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
+ ENTROPY_CONTEXT t_above[16], t_left[16];
- vpx_memcpy(&t_above, xd->above_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * bw * 2);
- vpx_memcpy(&t_left, xd->left_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * bh * 2);
+ vpx_memcpy(&t_above, xd->plane[0].above_context,
+ sizeof(ENTROPY_CONTEXT) * 8 * bw);
+ vpx_memcpy(&t_left, xd->plane[0].left_context,
+ sizeof(ENTROPY_CONTEXT) * 8 * bh);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, b * 64, PLANE_TYPE_Y_WITH_DC,
- (ENTROPY_CONTEXT *) &t_above[x_idx * 2],
- (ENTROPY_CONTEXT *) &t_left[y_idx * 2],
+ t_above + x_idx * 8, t_left + y_idx * 8,
TX_32X32, bw * bh * 64);
}
@@ -968,22 +932,17 @@ static int64_t rd_pick_intra4x4mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
int distortion = 0;
int tot_rate_y = 0;
int64_t total_rd = 0;
- ENTROPY_CONTEXT_PLANES t_above, t_left;
- ENTROPY_CONTEXT *ta, *tl;
+ ENTROPY_CONTEXT t_above[4], t_left[4];
int *bmode_costs;
- vpx_memcpy(&t_above, xd->above_context,
- sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&t_left, xd->left_context,
- sizeof(ENTROPY_CONTEXT_PLANES));
-
- ta = (ENTROPY_CONTEXT *)&t_above;
- tl = (ENTROPY_CONTEXT *)&t_left;
+ vpx_memcpy(t_above, xd->plane[0].above_context, sizeof(t_above));
+ vpx_memcpy(t_left, xd->plane[0].left_context, sizeof(t_left));
xd->mode_info_context->mbmi.mode = I4X4_PRED;
bmode_costs = mb->inter_bmode_costs;
for (i = 0; i < 16; i++) {
+ const int x_idx = i & 3, y_idx = i >> 2;
MODE_INFO *const mic = xd->mode_info_context;
const int mis = xd->mode_info_stride;
B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
@@ -1006,10 +965,9 @@ static int64_t rd_pick_intra4x4mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
xd->plane[0].dst.stride);
#endif
- total_rd += rd_pick_intra4x4block(
- cpi, mb, i, &best_mode,
- bmode_costs, ta + vp9_block2above[TX_4X4][i],
- tl + vp9_block2left[TX_4X4][i], &r, &ry, &d);
+ total_rd += rd_pick_intra4x4block(cpi, mb, i, &best_mode, bmode_costs,
+ t_above + x_idx, t_left + y_idx,
+ &r, &ry, &d);
cost += r;
distortion += d;
@@ -1099,9 +1057,7 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
MACROBLOCKD *xd = &x->e_mbd;
int64_t best_rd = INT64_MAX;
int distortion = 0, rate = 0;
- ENTROPY_CONTEXT_PLANES ta, tl;
- ENTROPY_CONTEXT *ta0, *ta1, besta0 = 0, besta1 = 0;
- ENTROPY_CONTEXT *tl0, *tl1, bestl0 = 0, bestl1 = 0;
+ ENTROPY_CONTEXT ta[2], tl[2], ta_temp[2], tl_temp[2];
// perform transformation of dimension 8x8
// note the input and output index mapping
int idx = (ib & 0x02) ? (ib + 2) : ib;
@@ -1118,6 +1074,8 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
xd->plane[0].dst.buf, xd->plane[0].dst.stride);
assert(ib < 16);
+ vpx_memcpy(ta, a, sizeof(ta));
+ vpx_memcpy(tl, l, sizeof(tl));
for (mode = DC_PRED; mode <= TM_PRED; mode++) {
int64_t this_rd;
int rate_t = 0;
@@ -1132,6 +1090,9 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
src, src_stride,
dst, xd->plane[0].dst.stride);
+ vpx_memcpy(ta_temp, ta, sizeof(ta));
+ vpx_memcpy(tl_temp, tl, sizeof(tl));
+
if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
TX_TYPE tx_type = get_tx_type_8x8(xd, ib);
if (tx_type != DCT_DCT)
@@ -1144,28 +1105,15 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
distortion = vp9_block_error_c(coeff,
BLOCK_OFFSET(xd->plane[0].dqcoeff, idx, 16), 64);
- vpx_memcpy(&ta, a, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&tl, l, sizeof(ENTROPY_CONTEXT_PLANES));
-
- ta0 = ((ENTROPY_CONTEXT*)&ta) + vp9_block2above[TX_8X8][idx];
- tl0 = ((ENTROPY_CONTEXT*)&tl) + vp9_block2left[TX_8X8][idx];
- ta1 = ta0 + 1;
- tl1 = tl0 + 1;
-
rate_t = cost_coeffs(cm, x, idx, PLANE_TYPE_Y_WITH_DC,
- ta0, tl0, TX_8X8, 16);
+ ta_temp, tl_temp, TX_8X8, 16);
rate += rate_t;
} else {
static const int iblock[4] = {0, 1, 4, 5};
TX_TYPE tx_type;
int i;
- vpx_memcpy(&ta, a, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&tl, l, sizeof(ENTROPY_CONTEXT_PLANES));
- ta0 = ((ENTROPY_CONTEXT*)&ta) + vp9_block2above[TX_4X4][ib];
- tl0 = ((ENTROPY_CONTEXT*)&tl) + vp9_block2left[TX_4X4][ib];
- ta1 = ta0 + 1;
- tl1 = tl0 + 1;
+
distortion = 0;
rate_t = 0;
for (i = 0; i < 4; ++i) {
@@ -1193,12 +1141,12 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
BLOCK_OFFSET(xd->plane[0].dqcoeff, ib + iblock[i], 16),
16 << do_two);
rate_t += cost_coeffs(cm, x, ib + iblock[i], PLANE_TYPE_Y_WITH_DC,
- i&1 ? ta1 : ta0, i&2 ? tl1 : tl0,
+ &ta_temp[i & 1], &tl_temp[i >> 1],
TX_4X4, 16);
if (do_two) {
i++;
rate_t += cost_coeffs(cm, x, ib + iblock[i], PLANE_TYPE_Y_WITH_DC,
- i&1 ? ta1 : ta0, i&2 ? tl1 : tl0,
+ &ta_temp[i & 1], &tl_temp[i >> 1],
TX_4X4, 16);
}
}
@@ -1211,10 +1159,8 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
*bestrate = rate;
*bestratey = rate_t;
*bestdistortion = distortion;
- besta0 = *ta0;
- besta1 = *ta1;
- bestl0 = *tl0;
- bestl1 = *tl1;
+ vpx_memcpy(a, ta_temp, sizeof(ta_temp));
+ vpx_memcpy(l, tl_temp, sizeof(tl_temp));
best_rd = this_rd;
*best_mode = mode;
}
@@ -1222,18 +1168,6 @@ static int64_t rd_pick_intra8x8block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
xd->mode_info_context->bmi[ib].as_mode.first = (*best_mode);
vp9_encode_intra8x8(x, ib);
- if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
- a[vp9_block2above[TX_8X8][idx]] = besta0;
- a[vp9_block2above[TX_8X8][idx] + 1] = besta1;
- l[vp9_block2left[TX_8X8][idx]] = bestl0;
- l[vp9_block2left[TX_8X8][idx] + 1] = bestl1;
- } else {
- a[vp9_block2above[TX_4X4][ib]] = besta0;
- a[vp9_block2above[TX_4X4][ib + 1]] = besta1;
- l[vp9_block2left[TX_4X4][ib]] = bestl0;
- l[vp9_block2left[TX_4X4][ib + 4]] = bestl1;
- }
-
return best_rd;
}
@@ -1246,28 +1180,25 @@ static int64_t rd_pick_intra8x8mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
int distortion = 0;
int tot_rate_y = 0;
int64_t total_rd = 0;
- ENTROPY_CONTEXT_PLANES t_above, t_left;
- ENTROPY_CONTEXT *ta, *tl;
+ ENTROPY_CONTEXT t_above[4], t_left[4];
int *i8x8mode_costs;
- vpx_memcpy(&t_above, xd->above_context, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&t_left, xd->left_context, sizeof(ENTROPY_CONTEXT_PLANES));
-
- ta = (ENTROPY_CONTEXT *)&t_above;
- tl = (ENTROPY_CONTEXT *)&t_left;
+ vpx_memcpy(t_above, xd->plane[0].above_context, sizeof(t_above));
+ vpx_memcpy(t_left, xd->plane[0].left_context, sizeof(t_left));
xd->mode_info_context->mbmi.mode = I8X8_PRED;
i8x8mode_costs = mb->i8x8_mode_costs;
for (i = 0; i < 4; i++) {
+ const int x_idx = i & 1, y_idx = i >> 1;
MODE_INFO *const mic = xd->mode_info_context;
B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(ry), UNINITIALIZED_IS_SAFE(d);
ib = vp9_i8x8_block[i];
- total_rd += rd_pick_intra8x8block(
- cpi, mb, ib, &best_mode,
- i8x8mode_costs, ta, tl, &r, &ry, &d);
+ total_rd += rd_pick_intra8x8block(cpi, mb, ib, &best_mode, i8x8mode_costs,
+ t_above + x_idx * 2, t_left + y_idx * 2,
+ &r, &ry, &d);
cost += r;
distortion += d;
tot_rate_y += ry;
@@ -1353,7 +1284,6 @@ static int64_t rd_pick_intra8x8mby_modes_and_txsz(VP9_COMP *cpi, MACROBLOCK *x,
return tmp_rd;
}
-#define UVCTX(c, p) ((p) ? (c).v : (c).u)
static int rd_cost_sbuv_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE_TYPE bsize) {
const int bwl = b_width_log2(bsize) - 1, bw = 1 << bwl;
@@ -1361,19 +1291,18 @@ static int rd_cost_sbuv_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
int yoff = 4 * bw * bh;
int p, b, cost = 0;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
- vpx_memcpy(&t_above, xd->above_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bw) >> 1);
- vpx_memcpy(&t_left, xd->left_context,
- (sizeof(ENTROPY_CONTEXT_PLANES) * bh) >> 1);
+ for (p = 1; p < MAX_MB_PLANE; p++) {
+ ENTROPY_CONTEXT t_above[8], t_left[8];
- for (p = 0; p < 2; p++) {
+ vpx_memcpy(t_above, xd->plane[p].above_context,
+ sizeof(ENTROPY_CONTEXT) * 2 * bw >> xd->plane[p].subsampling_x);
+ vpx_memcpy(t_left, xd->plane[p].left_context,
+ sizeof(ENTROPY_CONTEXT) * 2 * bh >> xd->plane[p].subsampling_y);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, yoff + b, PLANE_TYPE_UV,
- UVCTX(t_above[x_idx >> 1], p) + (x_idx & 1),
- UVCTX(t_left[y_idx >> 1], p) + (y_idx & 1),
+ t_above + x_idx, t_left + y_idx,
TX_4X4, bw * bh * 4);
}
yoff = (yoff * 5) >> 2; // u -> v
@@ -1402,19 +1331,18 @@ static int rd_cost_sbuv_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
int yoff = 16 * bw * bh;
int p, b, cost = 0;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
- vpx_memcpy(&t_above, xd->above_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * bw);
- vpx_memcpy(&t_left, xd->left_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * bh);
+ for (p = 1; p < MAX_MB_PLANE; p++) {
+ ENTROPY_CONTEXT t_above[8], t_left[8];
- for (p = 0; p < 2; p++) {
+ vpx_memcpy(t_above, xd->plane[p].above_context,
+ sizeof(ENTROPY_CONTEXT) * 4 * bw >> xd->plane[p].subsampling_x);
+ vpx_memcpy(t_left, xd->plane[p].left_context,
+ sizeof(ENTROPY_CONTEXT) * 4 * bh >> xd->plane[p].subsampling_y);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, yoff + b * 4, PLANE_TYPE_UV,
- UVCTX(t_above[x_idx], p),
- UVCTX(t_left[y_idx], p),
+ t_above + x_idx * 2, t_left + y_idx * 2,
TX_8X8, bw * bh * 16);
}
yoff = (yoff * 5) >> 2; // u -> v
@@ -1443,19 +1371,18 @@ static int rd_cost_sbuv_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
int yoff = 64 * bw * bh;
int p, b, cost = 0;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
- vpx_memcpy(&t_above, xd->above_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * 2 * bw);
- vpx_memcpy(&t_left, xd->left_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * 2 * bh);
+ for (p = 1; p < MAX_MB_PLANE; p++) {
+ ENTROPY_CONTEXT t_above[8], t_left[8];
- for (p = 0; p < 2; p++) {
+ vpx_memcpy(t_above, xd->plane[p].above_context,
+ sizeof(ENTROPY_CONTEXT) * 8 * bw >> xd->plane[p].subsampling_x);
+ vpx_memcpy(t_left, xd->plane[p].left_context,
+ sizeof(ENTROPY_CONTEXT) * 8 * bh >> xd->plane[p].subsampling_y);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b & (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, yoff + b * 16, PLANE_TYPE_UV,
- UVCTX(t_above[x_idx * 2], p),
- UVCTX(t_left[y_idx * 2], p),
+ t_above + x_idx * 4, t_left + y_idx * 4,
TX_16X16, bw * bh * 64);
}
yoff = (yoff * 5) >> 2; // u -> v
@@ -1484,19 +1411,18 @@ static int rd_cost_sbuv_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
int yoff = 256 * bh * bw;
int p, b, cost = 0;
MACROBLOCKD *const xd = &x->e_mbd;
- ENTROPY_CONTEXT_PLANES t_above[4], t_left[4];
- vpx_memcpy(&t_above, xd->above_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * 4 * bw);
- vpx_memcpy(&t_left, xd->left_context,
- sizeof(ENTROPY_CONTEXT_PLANES) * 4 * bh);
+ for (p = 1; p < MAX_MB_PLANE; p++) {
+ ENTROPY_CONTEXT t_above[8], t_left[8];
- for (p = 0; p < 2; p++) {
+ vpx_memcpy(t_above, xd->plane[p].above_context,
+ sizeof(ENTROPY_CONTEXT) * 16 * bw >> xd->plane[p].subsampling_x);
+ vpx_memcpy(t_left, xd->plane[p].left_context,
+ sizeof(ENTROPY_CONTEXT) * 16 * bh >> xd->plane[p].subsampling_y);
for (b = 0; b < bw * bh; b++) {
const int x_idx = b * (bw - 1), y_idx = b >> bwl;
cost += cost_coeffs(cm, x, yoff + b * 64, PLANE_TYPE_UV,
- UVCTX(t_above[x_idx * 4], p),
- UVCTX(t_left[y_idx * 4], p),
+ t_above + x_idx * 8, t_left + y_idx * 8,
TX_32X32, 256 * bh * bw);
}
yoff = (yoff * 5) >> 2; // u -> v
@@ -1775,8 +1701,8 @@ static int64_t encode_inter_mb_segment(VP9_COMMON *const cm,
BLOCK_OFFSET(xd->plane[0].dqcoeff, i, 16), 16);
*distortion += thisdistortion;
*labelyrate += cost_coeffs(cm, x, i, PLANE_TYPE_Y_WITH_DC,
- ta + vp9_block2above[TX_4X4][i],
- tl + vp9_block2left[TX_4X4][i], TX_4X4, 16);
+ ta + (i & 3),
+ tl + (i >> 2), TX_4X4, 16);
}
}
*distortion >>= 2;
@@ -1796,13 +1722,11 @@ static int64_t encode_inter_mb_segment_8x8(VP9_COMMON *const cm,
MACROBLOCKD *xd = &x->e_mbd;
const int iblock[4] = { 0, 1, 4, 5 };
int othercost = 0, otherdist = 0;
- ENTROPY_CONTEXT_PLANES tac, tlc;
- ENTROPY_CONTEXT *tacp = (ENTROPY_CONTEXT *) &tac,
- *tlcp = (ENTROPY_CONTEXT *) &tlc;
+ ENTROPY_CONTEXT tac[4], tlc[4];
if (otherrd) {
- memcpy(&tac, ta, sizeof(ENTROPY_CONTEXT_PLANES));
- memcpy(&tlc, tl, sizeof(ENTROPY_CONTEXT_PLANES));
+ memcpy(&tac, ta, sizeof(tac));
+ memcpy(&tlc, tl, sizeof(tlc));
}
*distortion = 0;
@@ -1860,8 +1784,8 @@ static int64_t encode_inter_mb_segment_8x8(VP9_COMMON *const cm,
otherdist += thisdistortion;
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
othercost += cost_coeffs(cm, x, idx, PLANE_TYPE_Y_WITH_DC,
- tacp + vp9_block2above[TX_8X8][idx],
- tlcp + vp9_block2left[TX_8X8][idx],
+ tac + (i & 1) * 2,
+ tlc + (i & 2),
TX_8X8, 16);
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
}
@@ -1879,14 +1803,14 @@ static int64_t encode_inter_mb_segment_8x8(VP9_COMMON *const cm,
*distortion += thisdistortion;
*labelyrate +=
cost_coeffs(cm, x, ib + iblock[j], PLANE_TYPE_Y_WITH_DC,
- ta + vp9_block2above[TX_4X4][ib + iblock[j]],
- tl + vp9_block2left[TX_4X4][ib + iblock[j]],
+ ta + (i & 1) * 2,
+ tl + (i & 2) + ((j & 2) >> 1),
TX_4X4, 16);
*labelyrate +=
cost_coeffs(cm, x, ib + iblock[j] + 1,
PLANE_TYPE_Y_WITH_DC,
- ta + vp9_block2above[TX_4X4][ib + iblock[j] + 1],
- tl + vp9_block2left[TX_4X4][ib + iblock[j]],
+ ta + (i & 1) * 2 + 1,
+ tl + (i & 2) + ((j & 2) >> 1),
TX_4X4, 16);
}
} else /* 8x8 */ {
@@ -1906,14 +1830,14 @@ static int64_t encode_inter_mb_segment_8x8(VP9_COMMON *const cm,
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
othercost +=
cost_coeffs(cm, x, ib + iblock[j], PLANE_TYPE_Y_WITH_DC,
- tacp + vp9_block2above[TX_4X4][ib + iblock[j]],
- tlcp + vp9_block2left[TX_4X4][ib + iblock[j]],
+ tac + (i & 1) * 2,
+ tlc + (i & 2) + ((j & 2) >> 1),
TX_4X4, 16);
othercost +=
cost_coeffs(cm, x, ib + iblock[j] + 1,
PLANE_TYPE_Y_WITH_DC,
- tacp + vp9_block2above[TX_4X4][ib + iblock[j] + 1],
- tlcp + vp9_block2left[TX_4X4][ib + iblock[j]],
+ tac + (i & 1) * 2 + 1,
+ tlc + (i & 2) + ((j & 2) >> 1),
TX_4X4, 16);
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
}
@@ -1924,9 +1848,9 @@ static int64_t encode_inter_mb_segment_8x8(VP9_COMMON *const cm,
BLOCK_OFFSET(xd->plane[0].dqcoeff, idx, 16), 64);
*distortion += thisdistortion;
*labelyrate += cost_coeffs(cm, x, idx, PLANE_TYPE_Y_WITH_DC,
- ta + vp9_block2above[TX_8X8][idx],
- tl + vp9_block2left[TX_8X8][idx], TX_8X8,
- 16);
+ ta + (i & 1) * 2,
+ tl + (i & 2),
+ TX_8X8, 16);
}
}
}
@@ -1996,18 +1920,11 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x,
vp9_variance_fn_ptr_t *v_fn_ptr;
- ENTROPY_CONTEXT_PLANES t_above, t_left;
- ENTROPY_CONTEXT *ta, *tl;
- ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
- ENTROPY_CONTEXT *ta_b, *tl_b;
+ ENTROPY_CONTEXT t_above[4], t_left[4];
+ ENTROPY_CONTEXT t_above_b[4], t_left_b[4];
- vpx_memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
-
- ta = (ENTROPY_CONTEXT *)&t_above;
- tl = (ENTROPY_CONTEXT *)&t_left;
- ta_b = (ENTROPY_CONTEXT *)&t_above_b;
- tl_b = (ENTROPY_CONTEXT *)&t_left_b;
+ vpx_memcpy(t_above, x->e_mbd.plane[0].above_context, sizeof(t_above));
+ vpx_memcpy(t_left, x->e_mbd.plane[0].left_context, sizeof(t_left));
v_fn_ptr = &cpi->fn_ptr[segmentation];
labels = vp9_mbsplits[segmentation];
@@ -2040,15 +1957,10 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x,
int64_t this_rd, other_rd;
int distortion;
int labelyrate;
- ENTROPY_CONTEXT_PLANES t_above_s, t_left_s;
- ENTROPY_CONTEXT *ta_s;
- ENTROPY_CONTEXT *tl_s;
-
- vpx_memcpy(&t_above_s, &t_above, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(&t_left_s, &t_left, sizeof(ENTROPY_CONTEXT_PLANES));
+ ENTROPY_CONTEXT t_above_s[4], t_left_s[4];
- ta_s = (ENTROPY_CONTEXT *)&t_above_s;
- tl_s = (ENTROPY_CONTEXT *)&t_left_s;
+ vpx_memcpy(t_above_s, t_above, sizeof(t_above_s));
+ vpx_memcpy(t_left_s, t_left, sizeof(t_left_s));
// motion search for newmv (single predictor case only)
if (mbmi->second_ref_frame <= 0 && this_mode == NEW4X4) {
@@ -2183,13 +2095,13 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x,
if (segmentation == PARTITIONING_4X4) {
this_rd = encode_inter_mb_segment(&cpi->common,
x, labels, i, &labelyrate,
- &distortion, ta_s, tl_s);
+ &distortion, t_above_s, t_left_s);
other_rd = this_rd;
} else {
this_rd = encode_inter_mb_segment_8x8(&cpi->common,
x, labels, i, &labelyrate,
&distortion, &other_rd,
- ta_s, tl_s);
+ t_above_s, t_left_s);
}
this_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
rate += labelyrate;
@@ -2215,14 +2127,14 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x,
if (other_rd < best_other_rd)
best_other_rd = other_rd;
- vpx_memcpy(ta_b, ta_s, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(tl_b, tl_s, sizeof(ENTROPY_CONTEXT_PLANES));
+ vpx_memcpy(t_above_b, t_above_s, sizeof(t_above_s));
+ vpx_memcpy(t_left_b, t_left_s, sizeof(t_left_s));
}
} /*for each 4x4 mode*/
- vpx_memcpy(ta, ta_b, sizeof(ENTROPY_CONTEXT_PLANES));
- vpx_memcpy(tl, tl_b, sizeof(ENTROPY_CONTEXT_PLANES));
+ vpx_memcpy(t_above, t_above_b, sizeof(t_above));
+ vpx_memcpy(t_left, t_left_b, sizeof(t_left));
labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected],
&second_mode_mv[mode_selected], seg_mvs[i],
diff --git a/vp9/encoder/vp9_segmentation.c b/vp9/encoder/vp9_segmentation.c
index bee39cd80..7f792ae2b 100644
--- a/vp9/encoder/vp9_segmentation.c
+++ b/vp9/encoder/vp9_segmentation.c
@@ -132,6 +132,9 @@ static void count_segs(VP9_COMP *cpi,
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
const int segment_id = mi->mbmi.segment_id;
+ if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
+
xd->mode_info_context = mi;
set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
@@ -159,6 +162,59 @@ static void count_segs(VP9_COMP *cpi,
}
}
+static void count_segs_sb(VP9_COMP *cpi, MODE_INFO *mi,
+ int *no_pred_segcounts,
+ int (*temporal_predictor_count)[2],
+ int *t_unpred_seg_counts,
+ int mi_row, int mi_col,
+ BLOCK_SIZE_TYPE bsize) {
+ VP9_COMMON *const cm = &cpi->common;
+ const int mis = cm->mode_info_stride;
+ int bwl, bhl;
+ const int bsl = mi_width_log2(bsize), bs = 1 << (bsl - 1);
+
+ if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
+ return;
+
+ bwl = mi_width_log2(mi->mbmi.sb_type);
+ bhl = mi_height_log2(mi->mbmi.sb_type);
+
+ if (bwl == bsl && bhl == bsl) {
+ count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, 1 << bsl, 1 << bsl, mi_row, mi_col);
+ } else if (bwl == bsl && bhl < bsl) {
+ count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, 1 << bsl, bs, mi_row, mi_col);
+ count_segs(cpi, mi + bs * mis, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, 1 << bsl, bs, mi_row + bs, mi_col);
+ } else if (bwl < bsl && bhl == bsl) {
+ count_segs(cpi, mi, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, bs, 1 << bsl, mi_row, mi_col);
+ count_segs(cpi, mi + bs, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, bs, 1 << bsl, mi_row, mi_col + bs);
+ } else {
+ BLOCK_SIZE_TYPE subsize;
+ int n;
+
+ assert(bwl < bsl && bhl < bsl);
+ if (bsize == BLOCK_SIZE_SB64X64) {
+ subsize = BLOCK_SIZE_SB32X32;
+ } else {
+ assert(bsize == BLOCK_SIZE_SB32X32);
+ subsize = BLOCK_SIZE_MB16X16;
+ }
+
+ for (n = 0; n < 4; n++) {
+ const int y_idx = n >> 1, x_idx = n & 0x01;
+
+ count_segs_sb(cpi, mi + y_idx * bs * mis + x_idx * bs,
+ no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts,
+ mi_row + y_idx * bs, mi_col + x_idx * bs, subsize);
+ }
+ }
+}
+
void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
VP9_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
@@ -203,92 +259,8 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
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 << 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 << 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 << 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 << 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++) {
- 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 (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 << 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 << 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 << 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 << 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) << 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 (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 << CONFIG_SB8X8, 1 << CONFIG_SB8X8,
- mi_row + y_idx_mb, mi_col + x_idx_mb);
- }
- }
- }
- }
+ count_segs_sb(cpi, mi, no_pred_segcounts, temporal_predictor_count,
+ t_unpred_seg_counts, mi_row, mi_col, BLOCK_SIZE_SB64X64);
}
}
}
diff --git a/vp9/encoder/vp9_tokenize.c b/vp9/encoder/vp9_tokenize.c
index 67e139053..3c3367071 100644
--- a/vp9/encoder/vp9_tokenize.c
+++ b/vp9/encoder/vp9_tokenize.c
@@ -96,30 +96,46 @@ static void fill_value_tokens() {
extern const int *vp9_get_coef_neighbors_handle(const int *scan, int *pad);
-static void tokenize_b(VP9_COMP *cpi,
- MACROBLOCKD *xd,
- const int ib,
- TOKENEXTRA **tp,
- PLANE_TYPE type,
- TX_SIZE tx_size,
- int y_blocks,
- int dry_run) {
+struct tokenize_b_args {
+ VP9_COMP *cpi;
+ MACROBLOCKD *xd;
+ TOKENEXTRA **tp;
+ TX_SIZE tx_size;
+ int dry_run;
+};
+static void tokenize_b(int plane, int block, BLOCK_SIZE_TYPE bsize,
+ int ss_txfrm_size, void *arg) {
+ struct tokenize_b_args* const args = arg;
+ VP9_COMP *cpi = args->cpi;
+ MACROBLOCKD *xd = args->xd;
+ TOKENEXTRA **tp = args->tp;
+ PLANE_TYPE type = plane ? PLANE_TYPE_UV : PLANE_TYPE_Y_WITH_DC;
+ TX_SIZE tx_size = ss_txfrm_size / 2;
+ int dry_run = args->dry_run;
+ int ib = old_block_idx_4x4(xd, b_width_log2(bsize) + b_height_log2(bsize),
+ plane, block);
+
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
int pt; /* near block/prev token context index */
int c = 0, rc = 0;
TOKENEXTRA *t = *tp; /* store tokens starting here */
- const struct plane_block_idx pb_idx = plane_block_idx(y_blocks, ib);
- const int eob = xd->plane[pb_idx.plane].eobs[pb_idx.block];
- const int16_t *qcoeff_ptr = BLOCK_OFFSET(xd->plane[pb_idx.plane].qcoeff,
- pb_idx.block, 16);
+ const int eob = xd->plane[plane].eobs[block];
+ const int16_t *qcoeff_ptr = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
+ const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
+ const int bwl = b_width_log2(sb_type);
+ const int off = block >> (2 * tx_size);
+ const int mod = bwl - tx_size - xd->plane[plane].subsampling_x;
+ const int aoff = (off & ((1 << mod) - 1)) << tx_size;
+ const int loff = (off >> mod) << tx_size;
+ ENTROPY_CONTEXT *A = xd->plane[plane].above_context + aoff;
+ ENTROPY_CONTEXT *L = xd->plane[plane].left_context + loff;
int seg_eob, default_eob, pad;
const int segment_id = mbmi->segment_id;
- const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
const int *scan, *nb;
vp9_coeff_count *counts;
vp9_coeff_probs *coef_probs;
const int ref = mbmi->ref_frame != INTRA_FRAME;
- ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
+ ENTROPY_CONTEXT above_ec, left_ec;
uint8_t token_cache[1024];
TX_TYPE tx_type = DCT_DCT;
#if CONFIG_CODE_ZEROGROUP
@@ -136,69 +152,15 @@ static void tokenize_b(VP9_COMP *cpi,
vpx_memset(token_cache, UNKNOWN_TOKEN, sizeof(token_cache));
#endif
- assert((!type && !pb_idx.plane) || (type && pb_idx.plane));
- if (sb_type == BLOCK_SIZE_SB64X64) {
- a = (ENTROPY_CONTEXT *)xd->above_context +
- vp9_block2above_sb64[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left_sb64[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a2 = a1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l2 = l1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a3 = a2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l3 = l2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- } else if (sb_type == BLOCK_SIZE_SB32X64) {
- a = (ENTROPY_CONTEXT *)xd->above_context +
- vp9_block2above_sb32x64[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context +
- vp9_block2left_sb32x64[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a2 = a3 = l2 = l3 = NULL;
- } else if (sb_type == BLOCK_SIZE_SB64X32) {
- a = (ENTROPY_CONTEXT *)xd->above_context +
- vp9_block2above_sb64x32[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context +
- vp9_block2left_sb64x32[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a2 = a3 = l2 = l3 = NULL;
- } else if (sb_type == BLOCK_SIZE_SB32X32) {
- a = (ENTROPY_CONTEXT *)xd->above_context + vp9_block2above_sb[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left_sb[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a2 = a3 = l2 = l3 = NULL;
- } else if (sb_type == BLOCK_SIZE_SB16X32) {
- a = (ENTROPY_CONTEXT *)xd->above_context +
- vp9_block2above_sb16x32[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context +
- vp9_block2left_sb16x32[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a1 = l1 = a2 = l2 = a3 = l3 = NULL;
- } else if (sb_type == BLOCK_SIZE_SB32X16) {
- a = (ENTROPY_CONTEXT *)xd->above_context +
- vp9_block2above_sb32x16[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context +
- vp9_block2left_sb32x16[tx_size][ib];
- a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
- a1 = l1 = a2 = l2 = a3 = l3 = NULL;
- } else {
- assert(sb_type == BLOCK_SIZE_MB16X16);
- a = (ENTROPY_CONTEXT *)xd->above_context + vp9_block2above[tx_size][ib];
- l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left[tx_size][ib];
- a1 = l1 = a2 = l2 = a3 = l3 = NULL;
- }
+ assert((!type && !plane) || (type && plane));
switch (tx_size) {
default:
case TX_4X4: {
tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type_4x4(xd, ib) : DCT_DCT;
- a_ec = *a;
- l_ec = *l;
+ above_ec = A[0] != 0;
+ left_ec = L[0] != 0;
seg_eob = 16;
scan = get_scan_4x4(tx_type);
counts = cpi->coef_counts_4x4;
@@ -214,8 +176,8 @@ static void tokenize_b(VP9_COMP *cpi,
const int x = ib & ((1 << sz) - 1), y = ib - x;
tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type_8x8(xd, y + (x >> 1)) : DCT_DCT;
- a_ec = (a[0] + a[1]) != 0;
- l_ec = (l[0] + l[1]) != 0;
+ above_ec = (A[0] + A[1]) != 0;
+ left_ec = (L[0] + L[1]) != 0;
seg_eob = 64;
scan = get_scan_8x8(tx_type);
counts = cpi->coef_counts_8x8;
@@ -231,13 +193,8 @@ static void tokenize_b(VP9_COMP *cpi,
const int x = ib & ((1 << sz) - 1), y = ib - x;
tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type_16x16(xd, y + (x >> 2)) : DCT_DCT;
- if (type != PLANE_TYPE_UV) {
- a_ec = (a[0] + a[1] + a[2] + a[3]) != 0;
- l_ec = (l[0] + l[1] + l[2] + l[3]) != 0;
- } else {
- a_ec = (a[0] + a[1] + a1[0] + a1[1]) != 0;
- l_ec = (l[0] + l[1] + l1[0] + l1[1]) != 0;
- }
+ above_ec = (A[0] + A[1] + A[2] + A[3]) != 0;
+ left_ec = (L[0] + L[1] + L[2] + L[3]) != 0;
seg_eob = 256;
scan = get_scan_16x16(tx_type);
counts = cpi->coef_counts_16x16;
@@ -249,17 +206,8 @@ static void tokenize_b(VP9_COMP *cpi,
break;
}
case TX_32X32:
- if (type != PLANE_TYPE_UV) {
- a_ec = (a[0] + a[1] + a[2] + a[3] +
- a1[0] + a1[1] + a1[2] + a1[3]) != 0;
- l_ec = (l[0] + l[1] + l[2] + l[3] +
- l1[0] + l1[1] + l1[2] + l1[3]) != 0;
- } else {
- a_ec = (a[0] + a[1] + a1[0] + a1[1] +
- a2[0] + a2[1] + a3[0] + a3[1]) != 0;
- l_ec = (l[0] + l[1] + l1[0] + l1[1] +
- l2[0] + l2[1] + l3[0] + l3[1]) != 0;
- }
+ above_ec = (A[0] + A[1] + A[2] + A[3] + A[4] + A[5] + A[6] + A[7]) != 0;
+ left_ec = (L[0] + L[1] + L[2] + L[3] + L[4] + L[5] + L[6] + L[7]) != 0;
seg_eob = 1024;
scan = vp9_default_zig_zag1d_32x32;
counts = cpi->coef_counts_32x32;
@@ -271,7 +219,7 @@ static void tokenize_b(VP9_COMP *cpi,
break;
}
- pt = combine_entropy_contexts(a_ec, l_ec);
+ pt = combine_entropy_contexts(above_ec, left_ec);
nb = vp9_get_coef_neighbors_handle(scan, &pad);
default_eob = seg_eob;
@@ -403,33 +351,8 @@ static void tokenize_b(VP9_COMP *cpi,
} while (c < eob && ++c < seg_eob);
*tp = t;
- a_ec = l_ec = (c > 0); /* 0 <-> all coeff data is zero */
- a[0] = a_ec;
- l[0] = l_ec;
-
- if (tx_size == TX_8X8) {
- a[1] = a_ec;
- l[1] = l_ec;
- } else if (tx_size == TX_16X16) {
- if (type != PLANE_TYPE_UV) {
- a[1] = a[2] = a[3] = a_ec;
- l[1] = l[2] = l[3] = l_ec;
- } else {
- a1[0] = a1[1] = a[1] = a_ec;
- l1[0] = l1[1] = l[1] = l_ec;
- }
- } else if (tx_size == TX_32X32) {
- if (type != PLANE_TYPE_UV) {
- a[1] = a[2] = a[3] = a_ec;
- l[1] = l[2] = l[3] = l_ec;
- a1[0] = a1[1] = a1[2] = a1[3] = a_ec;
- l1[0] = l1[1] = l1[2] = l1[3] = l_ec;
- } else {
- a[1] = a1[0] = a1[1] = a_ec;
- l[1] = l1[0] = l1[1] = l_ec;
- a2[0] = a2[1] = a3[0] = a3[1] = a_ec;
- l2[0] = l2[1] = l3[0] = l3[1] = l_ec;
- }
+ for (pt = 0; pt < (1 << tx_size); pt++) {
+ A[pt] = L[pt] = c > 0;
}
}
@@ -468,7 +391,6 @@ void vp9_tokenize_sb(VP9_COMP *cpi,
MACROBLOCKD *xd,
TOKENEXTRA **t,
int dry_run, BLOCK_SIZE_TYPE bsize) {
- const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
VP9_COMMON * const cm = &cpi->common;
MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
TOKENEXTRA *t_backup = *t;
@@ -476,12 +398,9 @@ void vp9_tokenize_sb(VP9_COMP *cpi,
const int segment_id = mbmi->segment_id;
const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
const TX_SIZE txfm_size = mbmi->txfm_size;
- const TX_SIZE uv_txfm_size = (bsize < BLOCK_SIZE_SB32X32 &&
- txfm_size == TX_16X16) ? TX_8X8 :
- (bsize < BLOCK_SIZE_SB64X64 &&
- txfm_size == TX_32X32) ? TX_16X16 : txfm_size;
- int b;
- const int n_y = (1 << (bwl + bhl)), n_uv = (n_y * 3) >> 1;
+ struct tokenize_b_args arg = {
+ cpi, xd, t, txfm_size, dry_run
+ };
mbmi->mb_skip_coeff = vp9_sb_is_skippable(xd, bsize);
@@ -497,121 +416,8 @@ void vp9_tokenize_sb(VP9_COMP *cpi,
if (!dry_run)
cpi->skip_false_count[mb_skip_context] += skip_inc;
- switch (txfm_size) {
- case TX_32X32:
- for (b = 0; b < n_y; b += 64)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
- TX_32X32, n_y, dry_run);
- if (uv_txfm_size == TX_32X32) {
- assert(bsize == BLOCK_SIZE_SB64X64);
- tokenize_b(cpi, xd, 256, t, PLANE_TYPE_UV,
- TX_32X32, n_y, dry_run);
- tokenize_b(cpi, xd, 320, t, PLANE_TYPE_UV,
- TX_32X32, n_y, dry_run);
- } else {
- for (; b < n_uv; b += 16)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
- TX_16X16, n_y, dry_run);
- }
- break;
- case TX_16X16:
- for (b = 0; b < n_y; b += 16)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
- TX_16X16, n_y, dry_run);
- if (uv_txfm_size == TX_16X16) {
- for (; b < n_uv; b += 16)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
- TX_16X16, n_y, dry_run);
- } else {
- for (; b < n_uv; b += 4)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
- TX_8X8, n_y, dry_run);
- }
- break;
- case TX_8X8:
- for (b = 0; b < n_y; b += 4)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
- TX_8X8, n_y, dry_run);
- for (; b < n_uv; b += 4)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
- TX_8X8, n_y, dry_run);
- break;
- case TX_4X4:
- for (b = 0; b < n_y; b++)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
- TX_4X4, n_y, dry_run);
- for (; b < n_uv; b++)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
- TX_4X4, n_y, dry_run);
- break;
- default: assert(0);
- }
-
- if (dry_run)
- *t = t_backup;
-}
+ foreach_transformed_block(xd, bsize, tokenize_b, &arg);
-void vp9_tokenize_mb(VP9_COMP *cpi,
- MACROBLOCKD *xd,
- TOKENEXTRA **t,
- int dry_run) {
- int b;
- int tx_size = xd->mode_info_context->mbmi.txfm_size;
- int mb_skip_context = vp9_get_pred_context(&cpi->common, xd, PRED_MBSKIP);
- TOKENEXTRA *t_backup = *t;
-
- // If the MB is going to be skipped because of a segment level flag
- // exclude this from the skip count stats used to calculate the
- // transmitted skip probability;
- int skip_inc;
- int segment_id = xd->mode_info_context->mbmi.segment_id;
-
- if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
- skip_inc = 1;
- } else
- skip_inc = 0;
-
- xd->mode_info_context->mbmi.mb_skip_coeff = vp9_sb_is_skippable(xd,
- BLOCK_SIZE_MB16X16);
-
- if (xd->mode_info_context->mbmi.mb_skip_coeff) {
- if (!dry_run)
- cpi->skip_true_count[mb_skip_context] += skip_inc;
- vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
-
- if (dry_run)
- *t = t_backup;
- return;
- }
-
- if (!dry_run)
- cpi->skip_false_count[mb_skip_context] += skip_inc;
-
- if (tx_size == TX_16X16) {
- tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, 16, dry_run);
- for (b = 16; b < 24; b += 4) {
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, 16, dry_run);
- }
- } else if (tx_size == TX_8X8) {
- for (b = 0; b < 16; b += 4) {
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, 16, dry_run);
- }
- if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
- xd->mode_info_context->mbmi.mode == SPLITMV) {
- for (b = 16; b < 24; b++) {
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, 16, dry_run);
- }
- } else {
- for (b = 16; b < 24; b += 4) {
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, 16, dry_run);
- }
- }
- } else {
- for (b = 0; b < 16; b++)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, 16, dry_run);
- for (b = 16; b < 24; b++)
- tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, 16, dry_run);
- }
if (dry_run)
*t = t_backup;
}
diff --git a/vp9/encoder/vp9_tokenize.h b/vp9/encoder/vp9_tokenize.h
index 816534830..bff5cfd4b 100644
--- a/vp9/encoder/vp9_tokenize.h
+++ b/vp9/encoder/vp9_tokenize.h
@@ -39,8 +39,6 @@ int vp9_sby_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize);
int vp9_sbuv_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize);
struct VP9_COMP;
-void vp9_tokenize_mb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
- TOKENEXTRA **t, int dry_run);
void vp9_tokenize_sb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run, BLOCK_SIZE_TYPE bsize);
diff --git a/vp9/encoder/vp9_variance_c.c b/vp9/encoder/vp9_variance_c.c
index f7916b4f0..c4c70df43 100644
--- a/vp9/encoder/vp9_variance_c.c
+++ b/vp9/encoder/vp9_variance_c.c
@@ -87,9 +87,9 @@ unsigned int vp9_sub_pixel_variance32x64_c(const uint8_t *src_ptr,
var_filter_block2d_bil_first_pass(src_ptr, fdata3, src_pixels_per_line,
1, 65, 32, hfilter);
- var_filter_block2d_bil_second_pass(fdata3, temp2, 64, 64, 64, 32, vfilter);
+ var_filter_block2d_bil_second_pass(fdata3, temp2, 32, 32, 64, 32, vfilter);
- return vp9_variance32x64_c(temp2, 64, dst_ptr, dst_pixels_per_line, sse);
+ return vp9_variance32x64_c(temp2, 32, dst_ptr, dst_pixels_per_line, sse);
}
unsigned int vp9_variance32x16_c(const uint8_t *src_ptr,
@@ -155,9 +155,9 @@ unsigned int vp9_sub_pixel_variance16x32_c(const uint8_t *src_ptr,
var_filter_block2d_bil_first_pass(src_ptr, fdata3, src_pixels_per_line,
1, 33, 16, hfilter);
- var_filter_block2d_bil_second_pass(fdata3, temp2, 32, 32, 32, 16, vfilter);
+ var_filter_block2d_bil_second_pass(fdata3, temp2, 16, 16, 32, 16, vfilter);
- return vp9_variance16x32_c(temp2, 32, dst_ptr, dst_pixels_per_line, sse);
+ return vp9_variance16x32_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse);
}
unsigned int vp9_variance64x64_c(const uint8_t *src_ptr,
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-13 07:21:06 +0000