Index: source/libvpx/vp9/encoder/vp9_tokenize.c |
=================================================================== |
--- source/libvpx/vp9/encoder/vp9_tokenize.c (revision 177019) |
+++ source/libvpx/vp9/encoder/vp9_tokenize.c (working copy) |
@@ -25,27 +25,21 @@ |
compressions, then generating vp9_context.c = initial stats. */ |
#ifdef ENTROPY_STATS |
-INT64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
-INT64 hybrid_context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
+vp9_coeff_accum context_counters_4x4[BLOCK_TYPES_4X4]; |
+vp9_coeff_accum hybrid_context_counters_4x4[BLOCK_TYPES_4X4]; |
+vp9_coeff_accum context_counters_8x8[BLOCK_TYPES_8X8]; |
+vp9_coeff_accum hybrid_context_counters_8x8[BLOCK_TYPES_8X8]; |
+vp9_coeff_accum context_counters_16x16[BLOCK_TYPES_16X16]; |
+vp9_coeff_accum hybrid_context_counters_16x16[BLOCK_TYPES_16X16]; |
+vp9_coeff_accum context_counters_32x32[BLOCK_TYPES_32X32]; |
-INT64 context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
-INT64 hybrid_context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
- |
-INT64 context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
-INT64 hybrid_context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; |
- |
-extern unsigned int tree_update_hist[BLOCK_TYPES][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES][2]; |
-extern unsigned int hybrid_tree_update_hist[BLOCK_TYPES][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES][2]; |
-extern unsigned int tree_update_hist_8x8[BLOCK_TYPES_8X8][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2]; |
-extern unsigned int hybrid_tree_update_hist_8x8[BLOCK_TYPES_8X8][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2]; |
-extern unsigned int tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2]; |
-extern unsigned int hybrid_tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS] |
- [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2]; |
+extern vp9_coeff_stats tree_update_hist_4x4[BLOCK_TYPES_4X4]; |
+extern vp9_coeff_stats hybrid_tree_update_hist_4x4[BLOCK_TYPES_4X4]; |
+extern vp9_coeff_stats tree_update_hist_8x8[BLOCK_TYPES_8X8]; |
+extern vp9_coeff_stats hybrid_tree_update_hist_8x8[BLOCK_TYPES_8X8]; |
+extern vp9_coeff_stats tree_update_hist_16x16[BLOCK_TYPES_16X16]; |
+extern vp9_coeff_stats hybrid_tree_update_hist_16x16[BLOCK_TYPES_16X16]; |
+extern vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES_32X32]; |
#endif /* ENTROPY_STATS */ |
static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2]; |
@@ -106,54 +100,78 @@ |
vp9_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE; |
} |
+#if CONFIG_NEWCOEFCONTEXT |
+#define PT pn |
+#else |
+#define PT pt |
+#endif |
+ |
static void tokenize_b(VP9_COMP *cpi, |
MACROBLOCKD *xd, |
- const BLOCKD * const b, |
+ const int ib, |
TOKENEXTRA **tp, |
PLANE_TYPE type, |
- ENTROPY_CONTEXT *a, |
- ENTROPY_CONTEXT *l, |
TX_SIZE tx_size, |
int dry_run) { |
int pt; /* near block/prev token context index */ |
int c = (type == PLANE_TYPE_Y_NO_DC) ? 1 : 0; |
+ const BLOCKD * const b = xd->block + ib; |
const int eob = b->eob; /* one beyond last nonzero coeff */ |
TOKENEXTRA *t = *tp; /* store tokens starting here */ |
- const short *qcoeff_ptr = b->qcoeff; |
+ int16_t *qcoeff_ptr = b->qcoeff; |
int seg_eob; |
- int segment_id = xd->mode_info_context->mbmi.segment_id; |
+ const int segment_id = xd->mode_info_context->mbmi.segment_id; |
const int *bands, *scan; |
- unsigned int (*counts)[COEF_BANDS][PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS]; |
- vp9_prob (*probs)[COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES]; |
+ vp9_coeff_count *counts; |
+ vp9_coeff_probs *probs; |
const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ? |
get_tx_type(xd, b) : DCT_DCT; |
+#if CONFIG_NEWCOEFCONTEXT |
+ const int *neighbors; |
+ int pn; |
+#endif |
- VP9_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
+ ENTROPY_CONTEXT *const a = (ENTROPY_CONTEXT *)xd->above_context + |
+ vp9_block2above[tx_size][ib]; |
+ ENTROPY_CONTEXT *const l = (ENTROPY_CONTEXT *)xd->left_context + |
+ vp9_block2left[tx_size][ib]; |
+ ENTROPY_CONTEXT a_ec = *a, l_ec = *l; |
+ |
+ ENTROPY_CONTEXT *const a1 = (ENTROPY_CONTEXT *)(&xd->above_context[1]) + |
+ vp9_block2above[tx_size][ib]; |
+ ENTROPY_CONTEXT *const l1 = (ENTROPY_CONTEXT *)(&xd->left_context[1]) + |
+ vp9_block2left[tx_size][ib]; |
+ |
+ |
switch (tx_size) { |
default: |
case TX_4X4: |
seg_eob = 16; |
- bands = vp9_coef_bands; |
- scan = vp9_default_zig_zag1d; |
+ bands = vp9_coef_bands_4x4; |
+ scan = vp9_default_zig_zag1d_4x4; |
if (tx_type != DCT_DCT) { |
- counts = cpi->hybrid_coef_counts; |
- probs = cpi->common.fc.hybrid_coef_probs; |
+ counts = cpi->hybrid_coef_counts_4x4; |
+ probs = cpi->common.fc.hybrid_coef_probs_4x4; |
if (tx_type == ADST_DCT) { |
- scan = vp9_row_scan; |
+ scan = vp9_row_scan_4x4; |
} else if (tx_type == DCT_ADST) { |
- scan = vp9_col_scan; |
+ scan = vp9_col_scan_4x4; |
} |
} else { |
- counts = cpi->coef_counts; |
- probs = cpi->common.fc.coef_probs; |
+ counts = cpi->coef_counts_4x4; |
+ probs = cpi->common.fc.coef_probs_4x4; |
} |
break; |
case TX_8X8: |
if (type == PLANE_TYPE_Y2) { |
seg_eob = 4; |
- bands = vp9_coef_bands; |
- scan = vp9_default_zig_zag1d; |
+ bands = vp9_coef_bands_4x4; |
+ scan = vp9_default_zig_zag1d_4x4; |
} else { |
+#if CONFIG_CNVCONTEXT |
+ a_ec = (a[0] + a[1]) != 0; |
+ l_ec = (l[0] + l[1]) != 0; |
+#endif |
seg_eob = 64; |
bands = vp9_coef_bands_8x8; |
scan = vp9_default_zig_zag1d_8x8; |
@@ -167,6 +185,15 @@ |
} |
break; |
case TX_16X16: |
+#if CONFIG_CNVCONTEXT |
+ 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; |
+ } |
+#endif |
seg_eob = 256; |
bands = vp9_coef_bands_16x16; |
scan = vp9_default_zig_zag1d_16x16; |
@@ -177,9 +204,35 @@ |
counts = cpi->coef_counts_16x16; |
probs = cpi->common.fc.coef_probs_16x16; |
} |
+ if (type == PLANE_TYPE_UV) { |
+ int uv_idx = (ib - 16) >> 2; |
+ qcoeff_ptr = xd->sb_coeff_data.qcoeff + 1024 + 256 * uv_idx; |
+ } |
break; |
+ case TX_32X32: |
+#if CONFIG_CNVCONTEXT |
+ a_ec = a[0] + a[1] + a[2] + a[3] + |
+ a1[0] + a1[1] + a1[2] + a1[3]; |
+ l_ec = l[0] + l[1] + l[2] + l[3] + |
+ l1[0] + l1[1] + l1[2] + l1[3]; |
+ a_ec = a_ec != 0; |
+ l_ec = l_ec != 0; |
+#endif |
+ seg_eob = 1024; |
+ bands = vp9_coef_bands_32x32; |
+ scan = vp9_default_zig_zag1d_32x32; |
+ counts = cpi->coef_counts_32x32; |
+ probs = cpi->common.fc.coef_probs_32x32; |
+ qcoeff_ptr = xd->sb_coeff_data.qcoeff; |
+ break; |
} |
+ VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec); |
+#if CONFIG_NEWCOEFCONTEXT |
+ neighbors = vp9_get_coef_neighbors_handle(scan); |
+ pn = pt; |
+#endif |
+ |
if (vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB)) |
seg_eob = vp9_get_segdata(xd, segment_id, SEG_LVL_EOB); |
@@ -190,7 +243,6 @@ |
if (c < eob) { |
const int rc = scan[c]; |
const int v = qcoeff_ptr[rc]; |
- |
assert(-DCT_MAX_VALUE <= v && v < DCT_MAX_VALUE); |
t->Extra = vp9_dct_value_tokens_ptr[v].Extra; |
@@ -200,19 +252,46 @@ |
} |
t->Token = token; |
- t->context_tree = probs[type][band][pt]; |
+ t->context_tree = probs[type][band][PT]; |
t->skip_eob_node = (pt == 0) && ((band > 0 && type != PLANE_TYPE_Y_NO_DC) || |
(band > 1 && type == PLANE_TYPE_Y_NO_DC)); |
assert(vp9_coef_encodings[t->Token].Len - t->skip_eob_node > 0); |
if (!dry_run) { |
- ++counts[type][band][pt][token]; |
+ ++counts[type][band][PT][token]; |
} |
pt = vp9_prev_token_class[token]; |
+#if CONFIG_NEWCOEFCONTEXT |
+ if (c < seg_eob - 1 && NEWCOEFCONTEXT_BAND_COND(bands[c + 1])) |
+ pn = vp9_get_coef_neighbor_context( |
+ qcoeff_ptr, (type == PLANE_TYPE_Y_NO_DC), neighbors, scan[c + 1]); |
+ else |
+ pn = pt; |
+#endif |
++t; |
} while (c < eob && ++c < seg_eob); |
*tp = t; |
- *a = *l = (c > !type); /* 0 <-> all coeff data is zero */ |
+ a_ec = l_ec = (c > !type); /* 0 <-> all coeff data is zero */ |
+ a[0] = a_ec; |
+ l[0] = l_ec; |
+ |
+ if (tx_size == TX_8X8 && type != PLANE_TYPE_Y2) { |
+ 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) { |
+ 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; |
+ } |
} |
int vp9_mby_is_skippable_4x4(MACROBLOCKD *xd, int has_2nd_order) { |
@@ -283,6 +362,68 @@ |
return (vp9_mby_is_skippable_16x16(xd) & vp9_mbuv_is_skippable_8x8(xd)); |
} |
+int vp9_sby_is_skippable_32x32(MACROBLOCKD *xd) { |
+ int skip = 1; |
+ skip &= !xd->block[0].eob; |
+ return skip; |
+} |
+ |
+int vp9_sbuv_is_skippable_16x16(MACROBLOCKD *xd) { |
+ return (!xd->block[16].eob) & (!xd->block[20].eob); |
+} |
+ |
+static int sb_is_skippable_32x32(MACROBLOCKD *xd) { |
+ return vp9_sby_is_skippable_32x32(xd) && |
+ vp9_sbuv_is_skippable_16x16(xd); |
+} |
+ |
+void vp9_tokenize_sb(VP9_COMP *cpi, |
+ MACROBLOCKD *xd, |
+ TOKENEXTRA **t, |
+ int dry_run) { |
+ VP9_COMMON * const cm = &cpi->common; |
+ MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi; |
+ TOKENEXTRA *t_backup = *t; |
+ ENTROPY_CONTEXT *A[2] = { (ENTROPY_CONTEXT *) (xd->above_context + 0), |
+ (ENTROPY_CONTEXT *) (xd->above_context + 1), }; |
+ ENTROPY_CONTEXT *L[2] = { (ENTROPY_CONTEXT *) (xd->left_context + 0), |
+ (ENTROPY_CONTEXT *) (xd->left_context + 1), }; |
+ const int mb_skip_context = vp9_get_pred_context(cm, xd, PRED_MBSKIP); |
+ const int segment_id = mbmi->segment_id; |
+ const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) || |
+ (vp9_get_segdata(xd, segment_id, SEG_LVL_EOB) != 0); |
+ int b; |
+ |
+ mbmi->mb_skip_coeff = sb_is_skippable_32x32(xd); |
+ |
+ if (mbmi->mb_skip_coeff) { |
+ if (!dry_run) |
+ cpi->skip_true_count[mb_skip_context] += skip_inc; |
+ if (!cm->mb_no_coeff_skip) { |
+ vp9_stuff_sb(cpi, xd, t, dry_run); |
+ } else { |
+ vp9_fix_contexts_sb(xd); |
+ } |
+ if (dry_run) |
+ *t = t_backup; |
+ return; |
+ } |
+ |
+ if (!dry_run) |
+ cpi->skip_false_count[mb_skip_context] += skip_inc; |
+ |
+ tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, |
+ TX_32X32, dry_run); |
+ |
+ for (b = 16; b < 24; b += 4) { |
+ tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, |
+ TX_16X16, dry_run); |
+ } |
+ A[0][8] = L[0][8] = A[1][8] = L[1][8] = 0; |
+ if (dry_run) |
+ *t = t_backup; |
+} |
+ |
void vp9_tokenize_mb(VP9_COMP *cpi, |
MACROBLOCKD *xd, |
TOKENEXTRA **t, |
@@ -293,8 +434,6 @@ |
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; |
- ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *) xd->above_context; |
- ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *) xd->left_context; |
// 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 |
@@ -312,6 +451,7 @@ |
switch (tx_size) { |
case TX_16X16: |
+ |
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(xd); |
break; |
case TX_8X8: |
@@ -336,8 +476,9 @@ |
if (!cpi->common.mb_no_coeff_skip) { |
vp9_stuff_mb(cpi, xd, t, dry_run); |
} else { |
- vp9_fix_contexts(xd); |
+ vp9_reset_mb_tokens_context(xd); |
} |
+ |
if (dry_run) |
*t = t_backup; |
return; |
@@ -347,120 +488,106 @@ |
cpi->skip_false_count[mb_skip_context] += skip_inc; |
if (has_2nd_order) { |
- if (tx_size == TX_8X8) { |
- tokenize_b(cpi, xd, xd->block + 24, t, PLANE_TYPE_Y2, |
- A + vp9_block2above_8x8[24], L + vp9_block2left_8x8[24], |
- TX_8X8, dry_run); |
- } else { |
- tokenize_b(cpi, xd, xd->block + 24, t, PLANE_TYPE_Y2, |
- A + vp9_block2above[24], L + vp9_block2left[24], |
- TX_4X4, dry_run); |
- } |
- |
+ tokenize_b(cpi, xd, 24, t, PLANE_TYPE_Y2, tx_size, dry_run); |
plane_type = PLANE_TYPE_Y_NO_DC; |
} else { |
- xd->above_context->y2 = 1; |
- xd->left_context->y2 = 1; |
+ xd->above_context->y2 = 0; |
+ xd->left_context->y2 = 0; |
plane_type = PLANE_TYPE_Y_WITH_DC; |
} |
if (tx_size == TX_16X16) { |
- tokenize_b(cpi, xd, xd->block, t, PLANE_TYPE_Y_WITH_DC, |
- A, L, TX_16X16, dry_run); |
- A[1] = A[2] = A[3] = A[0]; |
- L[1] = L[2] = L[3] = L[0]; |
- |
+ tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run); |
for (b = 16; b < 24; b += 4) { |
- tokenize_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, |
- A + vp9_block2above_8x8[b], L + vp9_block2left_8x8[b], |
- TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run); |
} |
- A[8] = 0; |
- L[8] = 0; |
} else if (tx_size == TX_8X8) { |
for (b = 0; b < 16; b += 4) { |
- tokenize_b(cpi, xd, xd->block + b, t, plane_type, |
- A + vp9_block2above_8x8[b], L + vp9_block2left_8x8[b], |
- TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ tokenize_b(cpi, xd, b, t, plane_type, TX_8X8, 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, xd->block + b, t, PLANE_TYPE_UV, |
- A + vp9_block2above[b], L + vp9_block2left[b], |
- TX_4X4, dry_run); |
+ tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run); |
} |
} else { |
for (b = 16; b < 24; b += 4) { |
- tokenize_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, |
- A + vp9_block2above_8x8[b], L + vp9_block2left_8x8[b], |
- TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run); |
} |
} |
} else { |
- for (b = 0; b < 16; b++) { |
- tokenize_b(cpi, xd, xd->block + b, t, plane_type, |
- A + vp9_block2above[b], L + vp9_block2left[b], |
- TX_4X4, dry_run); |
+ for (b = 0; b < 24; b++) { |
+ if (b >= 16) |
+ plane_type = PLANE_TYPE_UV; |
+ tokenize_b(cpi, xd, b, t, plane_type, TX_4X4, dry_run); |
} |
- |
- for (b = 16; b < 24; b++) { |
- tokenize_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, |
- A + vp9_block2above[b], L + vp9_block2left[b], |
- TX_4X4, dry_run); |
- } |
} |
if (dry_run) |
*t = t_backup; |
} |
- |
#ifdef ENTROPY_STATS |
void init_context_counters(void) { |
FILE *f = fopen("context.bin", "rb"); |
if (!f) { |
- vpx_memset(context_counters, 0, sizeof(context_counters)); |
+ vpx_memset(context_counters_4x4, 0, sizeof(context_counters_4x4)); |
+ vpx_memset(hybrid_context_counters_4x4, 0, |
+ sizeof(hybrid_context_counters_4x4)); |
vpx_memset(context_counters_8x8, 0, sizeof(context_counters_8x8)); |
+ vpx_memset(hybrid_context_counters_8x8, 0, |
+ sizeof(hybrid_context_counters_8x8)); |
vpx_memset(context_counters_16x16, 0, sizeof(context_counters_16x16)); |
+ vpx_memset(hybrid_context_counters_16x16, 0, |
+ sizeof(hybrid_context_counters_16x16)); |
+ vpx_memset(context_counters_32x32, 0, sizeof(context_counters_32x32)); |
} else { |
- fread(context_counters, sizeof(context_counters), 1, f); |
+ fread(context_counters_4x4, sizeof(context_counters_4x4), 1, f); |
+ fread(hybrid_context_counters_4x4, |
+ sizeof(hybrid_context_counters_4x4), 1, f); |
fread(context_counters_8x8, sizeof(context_counters_8x8), 1, f); |
+ fread(hybrid_context_counters_8x8, |
+ sizeof(hybrid_context_counters_8x8), 1, f); |
fread(context_counters_16x16, sizeof(context_counters_16x16), 1, f); |
+ fread(hybrid_context_counters_16x16, |
+ sizeof(hybrid_context_counters_16x16), 1, f); |
+ fread(context_counters_32x32, sizeof(context_counters_32x32), 1, f); |
fclose(f); |
} |
f = fopen("treeupdate.bin", "rb"); |
if (!f) { |
- vpx_memset(tree_update_hist, 0, sizeof(tree_update_hist)); |
+ vpx_memset(tree_update_hist_4x4, 0, sizeof(tree_update_hist_4x4)); |
+ vpx_memset(hybrid_tree_update_hist_4x4, 0, |
+ sizeof(hybrid_tree_update_hist_4x4)); |
vpx_memset(tree_update_hist_8x8, 0, sizeof(tree_update_hist_8x8)); |
+ vpx_memset(hybrid_tree_update_hist_8x8, 0, |
+ sizeof(hybrid_tree_update_hist_8x8)); |
vpx_memset(tree_update_hist_16x16, 0, sizeof(tree_update_hist_16x16)); |
+ vpx_memset(hybrid_tree_update_hist_16x16, 0, |
+ sizeof(hybrid_tree_update_hist_16x16)); |
+ vpx_memset(tree_update_hist_32x32, 0, sizeof(tree_update_hist_32x32)); |
} else { |
- fread(tree_update_hist, sizeof(tree_update_hist), 1, f); |
+ fread(tree_update_hist_4x4, sizeof(tree_update_hist_4x4), 1, f); |
+ fread(hybrid_tree_update_hist_4x4, |
+ sizeof(hybrid_tree_update_hist_4x4), 1, f); |
fread(tree_update_hist_8x8, sizeof(tree_update_hist_8x8), 1, f); |
+ fread(hybrid_tree_update_hist_8x8, |
+ sizeof(hybrid_tree_update_hist_8x8), 1, f); |
fread(tree_update_hist_16x16, sizeof(tree_update_hist_16x16), 1, f); |
+ fread(hybrid_tree_update_hist_16x16, |
+ sizeof(hybrid_tree_update_hist_16x16), 1, f); |
+ fread(tree_update_hist_32x32, sizeof(tree_update_hist_32x32), 1, f); |
fclose(f); |
} |
} |
-void print_context_counters() { |
+static void print_counter(FILE *f, vp9_coeff_accum *context_counters, |
+ int block_types, const char *header) { |
int type, band, pt, t; |
- FILE *f = fopen("vp9_context.c", "w"); |
- fprintf(f, "#include \"vp9_entropy.h\"\n"); |
- fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n"); |
- fprintf(f, "static const unsigned int\n" |
- "vp9_default_coef_counts[BLOCK_TYPES]\n" |
- " [COEF_BANDS]\n" |
- " [PREV_COEF_CONTEXTS]\n" |
- " [MAX_ENTROPY_TOKENS]={\n"); |
+ fprintf(f, "static const vp9_coeff_count %s = {\n", header); |
-# define Comma( X) (X? ",":"") |
+#define Comma(X) (X ? "," : "") |
type = 0; |
do { |
fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
@@ -473,192 +600,114 @@ |
t = 0; |
do { |
- const INT64 x = context_counters [type] [band] [pt] [t]; |
+ const int64_t x = context_counters[type][band][pt][t]; |
const int y = (int) x; |
- assert(x == (INT64) y); /* no overflow handling yet */ |
- fprintf(f, "%s %d", Comma(t), y); |
- } while (++t < MAX_ENTROPY_TOKENS); |
- fprintf(f, "}"); |
- } while (++pt < PREV_COEF_CONTEXTS); |
- fprintf(f, "\n }"); |
- } while (++band < COEF_BANDS); |
- fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES); |
- fprintf(f, "\n};\n"); |
- fprintf(f, "static const unsigned int\nvp9_default_coef_counts_8x8" |
- "[BLOCK_TYPES_8X8] [COEF_BANDS]" |
- "[PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS] = {"); |
- type = 0; |
- do { |
- fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
- band = 0; |
- do { |
- fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band); |
- pt = 0; |
- do { |
- fprintf(f, "%s\n {", Comma(pt)); |
- t = 0; |
- do { |
- const INT64 x = context_counters_8x8 [type] [band] [pt] [t]; |
- const int y = (int) x; |
- |
- assert(x == (INT64) y); /* no overflow handling yet */ |
+ assert(x == (int64_t) y); /* no overflow handling yet */ |
fprintf(f, "%s %d", Comma(t), y); |
- |
} while (++t < MAX_ENTROPY_TOKENS); |
- |
fprintf(f, "}"); |
} while (++pt < PREV_COEF_CONTEXTS); |
- |
fprintf(f, "\n }"); |
- |
} while (++band < COEF_BANDS); |
- |
fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES_8X8); |
+ } while (++type < block_types); |
fprintf(f, "\n};\n"); |
+} |
- fprintf(f, "static const unsigned int\nvp9_default_coef_counts_16x16" |
- "[BLOCK_TYPES_16X16] [COEF_BANDS]" |
- "[PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS] = {"); |
- type = 0; |
- do { |
- fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
- band = 0; |
- do { |
- fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band); |
- pt = 0; |
- do { |
- fprintf(f, "%s\n {", Comma(pt)); |
- t = 0; |
- do { |
- const INT64 x = context_counters_16x16 [type] [band] [pt] [t]; |
- const int y = (int) x; |
+static void print_probs(FILE *f, vp9_coeff_accum *context_counters, |
+ int block_types, const char *header) { |
+ int type, band, pt, t; |
- assert(x == (INT64) y); /* no overflow handling yet */ |
- fprintf(f, "%s %d", Comma(t), y); |
+ fprintf(f, "static const vp9_coeff_probs %s = {", header); |
- } while (++t < MAX_ENTROPY_TOKENS); |
- |
- fprintf(f, "}"); |
- } while (++pt < PREV_COEF_CONTEXTS); |
- |
- fprintf(f, "\n }"); |
- |
- } while (++band < COEF_BANDS); |
- |
- fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES_16X16); |
- fprintf(f, "\n};\n"); |
- |
- fprintf(f, "static const vp9_prob\n" |
- "vp9_default_coef_probs[BLOCK_TYPES] [COEF_BANDS] \n" |
- "[PREV_COEF_CONTEXTS] [ENTROPY_NODES] = {"); |
type = 0; |
+#define Newline(x, spaces) (x ? " " : "\n" spaces) |
do { |
- fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
+ fprintf(f, "%s%s{ /* block Type %d */", |
+ Comma(type), Newline(type, " "), type); |
band = 0; |
do { |
- fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band); |
+ fprintf(f, "%s%s{ /* Coeff Band %d */", |
+ Comma(band), Newline(band, " "), band); |
pt = 0; |
do { |
- unsigned int branch_ct [ENTROPY_NODES] [2]; |
+ unsigned int branch_ct[ENTROPY_NODES][2]; |
unsigned int coef_counts[MAX_ENTROPY_TOKENS]; |
vp9_prob coef_probs[ENTROPY_NODES]; |
+ |
for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) |
- coef_counts[t] = context_counters [type] [band] [pt] [t]; |
- vp9_tree_probs_from_distribution( |
- MAX_ENTROPY_TOKENS, vp9_coef_encodings, vp9_coef_tree, |
- coef_probs, branch_ct, coef_counts, 256, 1); |
+ coef_counts[t] = context_counters[type][band][pt][t]; |
+ vp9_tree_probs_from_distribution(MAX_ENTROPY_TOKENS, |
+ vp9_coef_encodings, vp9_coef_tree, |
+ coef_probs, branch_ct, coef_counts); |
fprintf(f, "%s\n {", Comma(pt)); |
t = 0; |
do { |
- fprintf(f, "%s %d", Comma(t), coef_probs[t]); |
- |
+ fprintf(f, "%s %3d", Comma(t), coef_probs[t]); |
} while (++t < ENTROPY_NODES); |
- fprintf(f, "}"); |
+ fprintf(f, " }"); |
} while (++pt < PREV_COEF_CONTEXTS); |
fprintf(f, "\n }"); |
} while (++band < COEF_BANDS); |
fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES); |
+ } while (++type < block_types); |
fprintf(f, "\n};\n"); |
+} |
- fprintf(f, "static const vp9_prob\n" |
- "vp9_default_coef_probs_8x8[BLOCK_TYPES_8X8] [COEF_BANDS]\n" |
- "[PREV_COEF_CONTEXTS] [ENTROPY_NODES] = {"); |
- type = 0; |
- do { |
- fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
- band = 0; |
- do { |
- fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band); |
- pt = 0; |
- do { |
- unsigned int branch_ct [ENTROPY_NODES] [2]; |
- unsigned int coef_counts[MAX_ENTROPY_TOKENS]; |
- vp9_prob coef_probs[ENTROPY_NODES]; |
- for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) |
- coef_counts[t] = context_counters_8x8[type] [band] [pt] [t]; |
- vp9_tree_probs_from_distribution( |
- MAX_ENTROPY_TOKENS, vp9_coef_encodings, vp9_coef_tree, |
- coef_probs, branch_ct, coef_counts, 256, 1); |
- fprintf(f, "%s\n {", Comma(pt)); |
+void print_context_counters() { |
+ FILE *f = fopen("vp9_context.c", "w"); |
- t = 0; |
- do { |
- fprintf(f, "%s %d", Comma(t), coef_probs[t]); |
- } while (++t < ENTROPY_NODES); |
- fprintf(f, "}"); |
- } while (++pt < PREV_COEF_CONTEXTS); |
- fprintf(f, "\n }"); |
- } while (++band < COEF_BANDS); |
- fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES_8X8); |
- fprintf(f, "\n};\n"); |
+ fprintf(f, "#include \"vp9_entropy.h\"\n"); |
+ fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n"); |
- fprintf(f, "static const vp9_prob\n" |
- "vp9_default_coef_probs_16x16[BLOCK_TYPES_16X16] [COEF_BANDS]\n" |
- "[PREV_COEF_CONTEXTS] [ENTROPY_NODES] = {"); |
- type = 0; |
- do { |
- fprintf(f, "%s\n { /* block Type %d */", Comma(type), type); |
- band = 0; |
- do { |
- fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band); |
- pt = 0; |
- do { |
- unsigned int branch_ct [ENTROPY_NODES] [2]; |
- unsigned int coef_counts[MAX_ENTROPY_TOKENS]; |
- vp9_prob coef_probs[ENTROPY_NODES]; |
- for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) |
- coef_counts[t] = context_counters_16x16[type] [band] [pt] [t]; |
- vp9_tree_probs_from_distribution( |
- MAX_ENTROPY_TOKENS, vp9_coef_encodings, vp9_coef_tree, |
- coef_probs, branch_ct, coef_counts, 256, 1); |
- fprintf(f, "%s\n {", Comma(pt)); |
+ /* print counts */ |
+ print_counter(f, context_counters_4x4, BLOCK_TYPES_4X4, |
+ "vp9_default_coef_counts_4x4[BLOCK_TYPES_4X4]"); |
+ print_counter(f, hybrid_context_counters_4x4, BLOCK_TYPES_4X4, |
+ "vp9_default_hybrid_coef_counts_4x4[BLOCK_TYPES_4X4]"); |
+ print_counter(f, context_counters_8x8, BLOCK_TYPES_8X8, |
+ "vp9_default_coef_counts_8x8[BLOCK_TYPES_8X8]"); |
+ print_counter(f, hybrid_context_counters_8x8, BLOCK_TYPES_8X8, |
+ "vp9_default_hybrid_coef_counts_8x8[BLOCK_TYPES_8X8]"); |
+ print_counter(f, context_counters_16x16, BLOCK_TYPES_16X16, |
+ "vp9_default_coef_counts_16x16[BLOCK_TYPES_16X16]"); |
+ print_counter(f, hybrid_context_counters_16x16, BLOCK_TYPES_16X16, |
+ "vp9_default_hybrid_coef_counts_16x16[BLOCK_TYPES_16X16]"); |
+ print_counter(f, context_counters_32x32, BLOCK_TYPES_32X32, |
+ "vp9_default_coef_counts_32x32[BLOCK_TYPES_32X32]"); |
- t = 0; |
- do { |
- fprintf(f, "%s %d", Comma(t), coef_probs[t]); |
- } while (++t < ENTROPY_NODES); |
- fprintf(f, "}"); |
- } while (++pt < PREV_COEF_CONTEXTS); |
- fprintf(f, "\n }"); |
- } while (++band < COEF_BANDS); |
- fprintf(f, "\n }"); |
- } while (++type < BLOCK_TYPES_16X16); |
- fprintf(f, "\n};\n"); |
+ /* print coefficient probabilities */ |
+ print_probs(f, context_counters_4x4, BLOCK_TYPES_4X4, |
+ "default_coef_probs_4x4[BLOCK_TYPES_4X4]"); |
+ print_probs(f, hybrid_context_counters_4x4, BLOCK_TYPES_4X4, |
+ "default_hybrid_coef_probs_4x4[BLOCK_TYPES_4X4]"); |
+ print_probs(f, context_counters_8x8, BLOCK_TYPES_8X8, |
+ "default_coef_probs_8x8[BLOCK_TYPES_8X8]"); |
+ print_probs(f, hybrid_context_counters_8x8, BLOCK_TYPES_8X8, |
+ "default_hybrid_coef_probs_8x8[BLOCK_TYPES_8X8]"); |
+ print_probs(f, context_counters_16x16, BLOCK_TYPES_16X16, |
+ "default_coef_probs_16x16[BLOCK_TYPES_16X16]"); |
+ print_probs(f, hybrid_context_counters_16x16, BLOCK_TYPES_16X16, |
+ "default_hybrid_coef_probs_16x16[BLOCK_TYPES_16X16]"); |
+ print_probs(f, context_counters_32x32, BLOCK_TYPES_32X32, |
+ "default_coef_probs_32x32[BLOCK_TYPES_32X32]"); |
fclose(f); |
f = fopen("context.bin", "wb"); |
- fwrite(context_counters, sizeof(context_counters), 1, f); |
+ fwrite(context_counters_4x4, sizeof(context_counters_4x4), 1, f); |
+ fwrite(hybrid_context_counters_4x4, |
+ sizeof(hybrid_context_counters_4x4), 1, f); |
fwrite(context_counters_8x8, sizeof(context_counters_8x8), 1, f); |
+ fwrite(hybrid_context_counters_8x8, |
+ sizeof(hybrid_context_counters_8x8), 1, f); |
fwrite(context_counters_16x16, sizeof(context_counters_16x16), 1, f); |
+ fwrite(hybrid_context_counters_16x16, |
+ sizeof(hybrid_context_counters_16x16), 1, f); |
+ fwrite(context_counters_32x32, sizeof(context_counters_32x32), 1, f); |
fclose(f); |
} |
#endif |
@@ -669,35 +718,48 @@ |
static __inline void stuff_b(VP9_COMP *cpi, |
MACROBLOCKD *xd, |
- const BLOCKD * const b, |
+ const int ib, |
TOKENEXTRA **tp, |
PLANE_TYPE type, |
- ENTROPY_CONTEXT *a, |
- ENTROPY_CONTEXT *l, |
TX_SIZE tx_size, |
int dry_run) { |
+ const BLOCKD * const b = xd->block + ib; |
const int *bands; |
- unsigned int (*counts)[COEF_BANDS][PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS]; |
- vp9_prob (*probs)[COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES]; |
+ vp9_coeff_count *counts; |
+ vp9_coeff_probs *probs; |
int pt, band; |
TOKENEXTRA *t = *tp; |
const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ? |
get_tx_type(xd, b) : DCT_DCT; |
- VP9_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
+ ENTROPY_CONTEXT *const a = (ENTROPY_CONTEXT *)xd->above_context + |
+ vp9_block2above[tx_size][ib]; |
+ ENTROPY_CONTEXT *const l = (ENTROPY_CONTEXT *)xd->left_context + |
+ vp9_block2left[tx_size][ib]; |
+ ENTROPY_CONTEXT a_ec = *a, l_ec = *l; |
+ ENTROPY_CONTEXT *const a1 = (ENTROPY_CONTEXT *)(&xd->above_context[1]) + |
+ vp9_block2above[tx_size][ib]; |
+ ENTROPY_CONTEXT *const l1 = (ENTROPY_CONTEXT *)(&xd->left_context[1]) + |
+ vp9_block2left[tx_size][ib]; |
switch (tx_size) { |
default: |
case TX_4X4: |
- bands = vp9_coef_bands; |
+ bands = vp9_coef_bands_4x4; |
if (tx_type != DCT_DCT) { |
- counts = cpi->hybrid_coef_counts; |
- probs = cpi->common.fc.hybrid_coef_probs; |
+ counts = cpi->hybrid_coef_counts_4x4; |
+ probs = cpi->common.fc.hybrid_coef_probs_4x4; |
} else { |
- counts = cpi->coef_counts; |
- probs = cpi->common.fc.coef_probs; |
+ counts = cpi->coef_counts_4x4; |
+ probs = cpi->common.fc.coef_probs_4x4; |
} |
break; |
case TX_8X8: |
+#if CONFIG_CNVCONTEXT |
+ if (type != PLANE_TYPE_Y2) { |
+ a_ec = (a[0] + a[1]) != 0; |
+ l_ec = (l[0] + l[1]) != 0; |
+ } |
+#endif |
bands = vp9_coef_bands_8x8; |
if (tx_type != DCT_DCT) { |
counts = cpi->hybrid_coef_counts_8x8; |
@@ -708,6 +770,15 @@ |
} |
break; |
case TX_16X16: |
+#if CONFIG_CNVCONTEXT |
+ 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; |
+ } |
+#endif |
bands = vp9_coef_bands_16x16; |
if (tx_type != DCT_DCT) { |
counts = cpi->hybrid_coef_counts_16x16; |
@@ -717,7 +788,23 @@ |
probs = cpi->common.fc.coef_probs_16x16; |
} |
break; |
+ case TX_32X32: |
+#if CONFIG_CNVCONTEXT |
+ a_ec = a[0] + a[1] + a[2] + a[3] + |
+ a1[0] + a1[1] + a1[2] + a1[3]; |
+ l_ec = l[0] + l[1] + l[2] + l[3] + |
+ l1[0] + l1[1] + l1[2] + l1[3]; |
+ a_ec = a_ec != 0; |
+ l_ec = l_ec != 0; |
+#endif |
+ bands = vp9_coef_bands_32x32; |
+ counts = cpi->coef_counts_32x32; |
+ probs = cpi->common.fc.coef_probs_32x32; |
+ break; |
} |
+ |
+ VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec); |
+ |
band = bands[(type == PLANE_TYPE_Y_NO_DC) ? 1 : 0]; |
t->Token = DCT_EOB_TOKEN; |
t->context_tree = probs[type][band][pt]; |
@@ -725,6 +812,24 @@ |
++t; |
*tp = t; |
*a = *l = 0; |
+ if (tx_size == TX_8X8 && type != PLANE_TYPE_Y2) { |
+ a[1] = 0; |
+ l[1] = 0; |
+ } else if (tx_size == TX_16X16) { |
+ if (type != PLANE_TYPE_UV) { |
+ a[1] = a[2] = a[3] = 0; |
+ l[1] = l[2] = l[3] = 0; |
+ } else { |
+ a1[0] = a1[1] = a[1] = a_ec; |
+ l1[0] = l1[1] = l[1] = l_ec; |
+ } |
+ } else if (tx_size == TX_32X32) { |
+ 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; |
+ } |
+ |
if (!dry_run) { |
++counts[type][band][pt][DCT_EOB_TOKEN]; |
} |
@@ -732,119 +837,86 @@ |
static void stuff_mb_8x8(VP9_COMP *cpi, MACROBLOCKD *xd, |
TOKENEXTRA **t, int dry_run) { |
- ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context; |
- ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context; |
PLANE_TYPE plane_type; |
int b; |
int has_2nd_order = get_2nd_order_usage(xd); |
if (has_2nd_order) { |
- stuff_b(cpi, xd, xd->block + 24, t, PLANE_TYPE_Y2, |
- A + vp9_block2above_8x8[24], L + vp9_block2left_8x8[24], |
- TX_8X8, dry_run); |
+ stuff_b(cpi, xd, 24, t, PLANE_TYPE_Y2, TX_8X8, dry_run); |
plane_type = PLANE_TYPE_Y_NO_DC; |
} else { |
- xd->above_context->y2 = 1; |
- xd->left_context->y2 = 1; |
+#if CONFIG_CNVCONTEXT |
+ xd->above_context->y2 = 0; |
+ xd->left_context->y2 = 0; |
+#endif |
plane_type = PLANE_TYPE_Y_WITH_DC; |
} |
- for (b = 0; b < 16; b += 4) { |
- stuff_b(cpi, xd, xd->block + b, t, plane_type, A + vp9_block2above_8x8[b], |
- L + vp9_block2left_8x8[b], TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ for (b = 0; b < 24; b += 4) { |
+ if (b >= 16) |
+ plane_type = PLANE_TYPE_UV; |
+ stuff_b(cpi, xd, b, t, plane_type, TX_8X8, dry_run); |
} |
- |
- for (b = 16; b < 24; b += 4) { |
- stuff_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, |
- A + vp9_block2above_8x8[b], L + vp9_block2left_8x8[b], |
- TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
- } |
} |
static void stuff_mb_16x16(VP9_COMP *cpi, MACROBLOCKD *xd, |
TOKENEXTRA **t, int dry_run) { |
- ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context; |
- ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context; |
int b; |
+ stuff_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run); |
- stuff_b(cpi, xd, xd->block, t, PLANE_TYPE_Y_WITH_DC, A, L, TX_16X16, dry_run); |
- A[1] = A[2] = A[3] = A[0]; |
- L[1] = L[2] = L[3] = L[0]; |
for (b = 16; b < 24; b += 4) { |
- stuff_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, A + vp9_block2above[b], |
- L + vp9_block2above_8x8[b], TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run); |
} |
- vpx_memset(&A[8], 0, sizeof(A[8])); |
- vpx_memset(&L[8], 0, sizeof(L[8])); |
+#if CONFIG_CNVCONTEXT |
+ xd->above_context->y2 = 0; |
+ xd->left_context->y2 = 0; |
+#endif |
} |
static void stuff_mb_4x4(VP9_COMP *cpi, MACROBLOCKD *xd, |
TOKENEXTRA **t, int dry_run) { |
- ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context; |
- ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context; |
int b; |
PLANE_TYPE plane_type; |
- int has_2nd_order = (xd->mode_info_context->mbmi.mode != B_PRED && |
- xd->mode_info_context->mbmi.mode != I8X8_PRED && |
- xd->mode_info_context->mbmi.mode != SPLITMV); |
- if (has_2nd_order && get_tx_type(xd, &xd->block[0]) != DCT_DCT) |
- has_2nd_order = 0; |
+ int has_2nd_order = get_2nd_order_usage(xd); |
if (has_2nd_order) { |
- stuff_b(cpi, xd, xd->block + 24, t, PLANE_TYPE_Y2, A + vp9_block2above[24], |
- L + vp9_block2left[24], TX_4X4, dry_run); |
+ stuff_b(cpi, xd, 24, t, PLANE_TYPE_Y2, TX_4X4, dry_run); |
plane_type = PLANE_TYPE_Y_NO_DC; |
} else { |
- xd->above_context->y2 = 1; |
- xd->left_context->y2 = 1; |
+ xd->above_context->y2 = 0; |
+ xd->left_context->y2 = 0; |
plane_type = PLANE_TYPE_Y_WITH_DC; |
} |
- for (b = 0; b < 16; b++) |
- stuff_b(cpi, xd, xd->block + b, t, plane_type, A + vp9_block2above[b], |
- L + vp9_block2left[b], TX_4X4, dry_run); |
- |
- for (b = 16; b < 24; b++) |
- stuff_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, A + vp9_block2above[b], |
- L + vp9_block2left[b], TX_4X4, dry_run); |
+ for (b = 0; b < 24; b++) { |
+ if (b >= 16) |
+ plane_type = PLANE_TYPE_UV; |
+ stuff_b(cpi, xd, b, t, plane_type, TX_4X4, dry_run); |
+ } |
} |
static void stuff_mb_8x8_4x4uv(VP9_COMP *cpi, MACROBLOCKD *xd, |
TOKENEXTRA **t, int dry_run) { |
- ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context; |
- ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context; |
PLANE_TYPE plane_type; |
int b; |
int has_2nd_order = get_2nd_order_usage(xd); |
if (has_2nd_order) { |
- stuff_b(cpi, xd, xd->block + 24, t, PLANE_TYPE_Y2, |
- A + vp9_block2above_8x8[24], L + vp9_block2left_8x8[24], |
- TX_8X8, dry_run); |
+ stuff_b(cpi, xd, 24, t, PLANE_TYPE_Y2, TX_8X8, dry_run); |
plane_type = PLANE_TYPE_Y_NO_DC; |
} else { |
+ xd->above_context->y2 = 0; |
+ xd->left_context->y2 = 0; |
plane_type = PLANE_TYPE_Y_WITH_DC; |
} |
for (b = 0; b < 16; b += 4) { |
- stuff_b(cpi, xd, xd->block + b, t, plane_type, |
- A + vp9_block2above_8x8[b], L + vp9_block2left_8x8[b], |
- TX_8X8, dry_run); |
- A[vp9_block2above_8x8[b] + 1] = A[vp9_block2above_8x8[b]]; |
- L[vp9_block2left_8x8[b] + 1] = L[vp9_block2left_8x8[b]]; |
+ stuff_b(cpi, xd, b, t, plane_type, TX_8X8, dry_run); |
} |
- for (b = 16; b < 24; b++) |
- stuff_b(cpi, xd, xd->block + b, t, PLANE_TYPE_UV, A + vp9_block2above[b], |
- L + vp9_block2left[b], TX_4X4, dry_run); |
- xd->above_context->y2 = 1; |
- xd->left_context->y2 = 1; |
+ for (b = 16; b < 24; b++) { |
+ stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run); |
+ } |
} |
void vp9_stuff_mb(VP9_COMP *cpi, MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run) { |
@@ -869,19 +941,27 @@ |
} |
} |
-void vp9_fix_contexts(MACROBLOCKD *xd) { |
- /* Clear entropy contexts for blocks */ |
- if ((xd->mode_info_context->mbmi.mode != B_PRED |
- && xd->mode_info_context->mbmi.mode != I8X8_PRED |
- && xd->mode_info_context->mbmi.mode != SPLITMV) |
- || xd->mode_info_context->mbmi.txfm_size == TX_16X16 |
- ) { |
- vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); |
- vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); |
- } else { |
- vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1); |
- vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1); |
- xd->above_context->y2 = 1; |
- xd->left_context->y2 = 1; |
+static void stuff_sb_32x32(VP9_COMP *cpi, MACROBLOCKD *xd, |
+ TOKENEXTRA **t, int dry_run) { |
+ int b; |
+ |
+ stuff_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_32X32, dry_run); |
+ for (b = 16; b < 24; b += 4) { |
+ stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run); |
} |
} |
+ |
+void vp9_stuff_sb(VP9_COMP *cpi, MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run) { |
+ TOKENEXTRA * const t_backup = *t; |
+ |
+ stuff_sb_32x32(cpi, xd, t, dry_run); |
+ |
+ if (dry_run) { |
+ *t = t_backup; |
+ } |
+} |
+ |
+void vp9_fix_contexts_sb(MACROBLOCKD *xd) { |
+ vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * 2); |
+ vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * 2); |
+} |