generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
vpx/vp9/encoder/vp9_tokenize.c
Ronald S. Bultje 111ca42133 Make superblocks independent of macroblock code and data. 
Split macroblock and superblock tokenization and detokenization
functions and coefficient-related data structs so that the bitstream
layout and related code of superblock coefficients looks less like it's
a hack to fit macroblocks in superblocks.

In addition, unify chroma transform size selection from luma transform
size (i.e. always use the same size, as long as it fits the predictor);
in practice, this means 32x32 and 64x64 superblocks using the 16x16 luma
transform will now use the 16x16 (instead of the 8x8) chroma transform,
and 64x64 superblocks using the 32x32 luma transform will now use the
32x32 (instead of the 16x16) chroma transform.

Lastly, add a trellis optimize function for 32x32 transform blocks.

HD gains about 0.3%, STDHD about 0.15% and derf about 0.1%. There's
a few negative points here and there that I might want to analyze
a little closer.

Change-Id: Ibad7c3ddfe1acfc52771dfc27c03e9783e054430
2013-03-04 16:34:36 -08:00

1153 lines
34 KiB
C
Raw Blame History

/*
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "vp9/encoder/vp9_onyx_int.h"
#include "vp9/encoder/vp9_tokenize.h"
#include "vpx_mem/vpx_mem.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_entropy.h"
/* Global event counters used for accumulating statistics across several
compressions, then generating vp9_context.c = initial stats. */
#ifdef ENTROPY_STATS
vp9_coeff_accum context_counters_4x4[BLOCK_TYPES];
vp9_coeff_accum context_counters_8x8[BLOCK_TYPES];
vp9_coeff_accum context_counters_16x16[BLOCK_TYPES];
vp9_coeff_accum context_counters_32x32[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_4x4[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_8x8[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_16x16[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES];
#endif /* ENTROPY_STATS */
static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2];
const TOKENVALUE *vp9_dct_value_tokens_ptr;
static int dct_value_cost[DCT_MAX_VALUE * 2];
const int *vp9_dct_value_cost_ptr;
static void fill_value_tokens() {
TOKENVALUE *const t = dct_value_tokens + DCT_MAX_VALUE;
vp9_extra_bit_struct *const e = vp9_extra_bits;
int i = -DCT_MAX_VALUE;
int sign = 1;
do {
if (!i)
sign = 0;
{
const int a = sign ? -i : i;
int eb = sign;
if (a > 4) {
int j = 4;
while (++j < 11 && e[j].base_val <= a) {}
t[i].Token = --j;
eb |= (a - e[j].base_val) << 1;
} else
t[i].Token = a;
t[i].Extra = eb;
}
// initialize the cost for extra bits for all possible coefficient value.
{
int cost = 0;
vp9_extra_bit_struct *p = vp9_extra_bits + t[i].Token;
if (p->base_val) {
const int extra = t[i].Extra;
const int Length = p->Len;
if (Length)
cost += treed_cost(p->tree, p->prob, extra >> 1, Length);
cost += vp9_cost_bit(vp9_prob_half, extra & 1); /* sign */
dct_value_cost[i + DCT_MAX_VALUE] = cost;
}
}
} while (++i < DCT_MAX_VALUE);
vp9_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE;
vp9_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE;
}
static void tokenize_b(VP9_COMP *cpi,
MACROBLOCKD *xd,
const int ib,
TOKENEXTRA **tp,
PLANE_TYPE type,
TX_SIZE tx_size,
int dry_run) {
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
int pt; /* near block/prev token context index */
int c = 0;
int recent_energy = 0;
const int eob = xd->eobs[ib]; /* one beyond last nonzero coeff */
TOKENEXTRA *t = *tp; /* store tokens starting here */
int16_t *qcoeff_ptr = xd->qcoeff + 16 * ib;
int seg_eob;
const int segment_id = mbmi->segment_id;
const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
const int *scan;
vp9_coeff_count *counts;
vp9_coeff_probs *probs;
const TX_TYPE tx_type = (sb_type == BLOCK_SIZE_MB16X16 &&
type == PLANE_TYPE_Y_WITH_DC) ?
get_tx_type(xd, &xd->block[ib]) : DCT_DCT;
const int ref = mbmi->ref_frame != INTRA_FRAME;
ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
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_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 {
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;
}
switch (tx_size) {
default:
case TX_4X4:
a_ec = *a;
l_ec = *l;
seg_eob = 16;
scan = vp9_default_zig_zag1d_4x4;
if (tx_type != DCT_DCT) {
if (tx_type == ADST_DCT) {
scan = vp9_row_scan_4x4;
} else if (tx_type == DCT_ADST) {
scan = vp9_col_scan_4x4;
}
}
counts = cpi->coef_counts_4x4;
probs = cpi->common.fc.coef_probs_4x4;
break;
case TX_8X8:
a_ec = (a[0] + a[1]) != 0;
l_ec = (l[0] + l[1]) != 0;
seg_eob = 64;
scan = vp9_default_zig_zag1d_8x8;
counts = cpi->coef_counts_8x8;
probs = cpi->common.fc.coef_probs_8x8;
break;
case TX_16X16:
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;
}
seg_eob = 256;
scan = vp9_default_zig_zag1d_16x16;
counts = cpi->coef_counts_16x16;
probs = cpi->common.fc.coef_probs_16x16;
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;
}
seg_eob = 1024;
scan = vp9_default_zig_zag1d_32x32;
counts = cpi->coef_counts_32x32;
probs = cpi->common.fc.coef_probs_32x32;
break;
}
VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec);
if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP))
seg_eob = 0;
do {
const int band = get_coef_band(tx_size, c);
int token;
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;
token = vp9_dct_value_tokens_ptr[v].Token;
} else {
token = DCT_EOB_TOKEN;
}
t->Token = token;
t->context_tree = probs[type][ref][band][pt];
t->skip_eob_node = (pt == 0) && (band > 0);
assert(vp9_coef_encodings[t->Token].Len - t->skip_eob_node > 0);
if (!dry_run) {
++counts[type][ref][band][pt][token];
}
pt = vp9_get_coef_context(&recent_energy, token);
++t;
} 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;
}
}
}
int vp9_mby_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 16; i++)
skip &= (!xd->eobs[i]);
return skip;
}
int vp9_mbuv_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i;
for (i = 16; i < 24; i++)
skip &= (!xd->eobs[i]);
return skip;
}
static int mb_is_skippable_4x4(MACROBLOCKD *xd) {
return (vp9_mby_is_skippable_4x4(xd) &
vp9_mbuv_is_skippable_4x4(xd));
}
int vp9_mby_is_skippable_8x8(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 16; i += 4)
skip &= (!xd->eobs[i]);
return skip;
}
int vp9_mbuv_is_skippable_8x8(MACROBLOCKD *xd) {
return (!xd->eobs[16]) & (!xd->eobs[20]);
}
static int mb_is_skippable_8x8(MACROBLOCKD *xd) {
return (vp9_mby_is_skippable_8x8(xd) &
vp9_mbuv_is_skippable_8x8(xd));
}
static int mb_is_skippable_8x8_4x4uv(MACROBLOCKD *xd) {
return (vp9_mby_is_skippable_8x8(xd) &
vp9_mbuv_is_skippable_4x4(xd));
}
int vp9_mby_is_skippable_16x16(MACROBLOCKD *xd) {
return (!xd->eobs[0]);
}
static int mb_is_skippable_16x16(MACROBLOCKD *xd) {
return (vp9_mby_is_skippable_16x16(xd) & vp9_mbuv_is_skippable_8x8(xd));
}
int vp9_sby_is_skippable_32x32(MACROBLOCKD *xd) {
return (!xd->eobs[0]);
}
int vp9_sbuv_is_skippable_16x16(MACROBLOCKD *xd) {
return (!xd->eobs[64]) & (!xd->eobs[80]);
}
static int sb_is_skippable_32x32(MACROBLOCKD *xd) {
return vp9_sby_is_skippable_32x32(xd) &&
vp9_sbuv_is_skippable_16x16(xd);
}
static int sby_is_skippable_16x16(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 64; i += 16)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb_is_skippable_16x16(MACROBLOCKD *xd) {
return sby_is_skippable_16x16(xd) & vp9_sbuv_is_skippable_16x16(xd);
}
static int sby_is_skippable_8x8(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 64; i += 4)
skip &= (!xd->eobs[i]);
return skip;
}
static int sbuv_is_skippable_8x8(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 64; i < 96; i += 4)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb_is_skippable_8x8(MACROBLOCKD *xd) {
return sby_is_skippable_8x8(xd) & sbuv_is_skippable_8x8(xd);
}
static int sby_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 64; i++)
skip &= (!xd->eobs[i]);
return skip;
}
static int sbuv_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 64; i < 96; i++)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb_is_skippable_4x4(MACROBLOCKD *xd) {
return sby_is_skippable_4x4(xd) & sbuv_is_skippable_4x4(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;
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_SKIP);
int b;
switch (mbmi->txfm_size) {
case TX_32X32:
mbmi->mb_skip_coeff = sb_is_skippable_32x32(xd);
break;
case TX_16X16:
mbmi->mb_skip_coeff = sb_is_skippable_16x16(xd);
break;
case TX_8X8:
mbmi->mb_skip_coeff = sb_is_skippable_8x8(xd);
break;
case TX_4X4:
mbmi->mb_skip_coeff = sb_is_skippable_4x4(xd);
break;
default: assert(0);
}
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_reset_sb_tokens_context(xd);
}
if (dry_run)
*t = t_backup;
return;
}
if (!dry_run)
cpi->skip_false_count[mb_skip_context] += skip_inc;
switch (mbmi->txfm_size) {
case TX_32X32:
tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC,
TX_32X32, dry_run);
for (b = 64; b < 96; b += 16)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_16X16, dry_run);
break;
case TX_16X16:
for (b = 0; b < 64; b += 16)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_16X16, dry_run);
for (b = 64; b < 96; b += 16)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_16X16, dry_run);
break;
case TX_8X8:
for (b = 0; b < 64; b += 4)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_8X8, dry_run);
for (b = 64; b < 96; b += 4)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_8X8, dry_run);
break;
case TX_4X4:
for (b = 0; b < 64; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_4X4, dry_run);
for (b = 64; b < 96; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_4X4, dry_run);
break;
default: assert(0);
}
if (dry_run)
*t = t_backup;
}
static int sb64y_is_skippable_32x32(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 256; i += 64)
skip &= (!xd->eobs[i]);
return skip;
}
int vp9_sb64uv_is_skippable_32x32(MACROBLOCKD *xd) {
return (!xd->eobs[256]) & (!xd->eobs[320]);
}
static int sb64_is_skippable_32x32(MACROBLOCKD *xd) {
return sb64y_is_skippable_32x32(xd) & vp9_sb64uv_is_skippable_32x32(xd);
}
static int sb64y_is_skippable_16x16(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 256; i += 16)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64uv_is_skippable_16x16(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 256; i < 384; i += 16)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64_is_skippable_16x16(MACROBLOCKD *xd) {
return sb64y_is_skippable_16x16(xd) & sb64uv_is_skippable_16x16(xd);
}
static int sb64y_is_skippable_8x8(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 256; i += 4)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64uv_is_skippable_8x8(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 256; i < 384; i += 4)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64_is_skippable_8x8(MACROBLOCKD *xd) {
return sb64y_is_skippable_8x8(xd) & sb64uv_is_skippable_8x8(xd);
}
static int sb64y_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 0; i < 256; i++)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64uv_is_skippable_4x4(MACROBLOCKD *xd) {
int skip = 1;
int i = 0;
for (i = 256; i < 384; i++)
skip &= (!xd->eobs[i]);
return skip;
}
static int sb64_is_skippable_4x4(MACROBLOCKD *xd) {
return sb64y_is_skippable_4x4(xd) & sb64uv_is_skippable_4x4(xd);
}
void vp9_tokenize_sb64(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;
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_SKIP);
int b;
switch (mbmi->txfm_size) {
case TX_32X32:
mbmi->mb_skip_coeff = sb64_is_skippable_32x32(xd);
break;
case TX_16X16:
mbmi->mb_skip_coeff = sb64_is_skippable_16x16(xd);
break;
case TX_8X8:
mbmi->mb_skip_coeff = sb64_is_skippable_8x8(xd);
break;
case TX_4X4:
mbmi->mb_skip_coeff = sb64_is_skippable_4x4(xd);
break;
default: assert(0);
}
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_sb64(cpi, xd, t, dry_run);
} else {
vp9_reset_sb64_tokens_context(xd);
}
if (dry_run)
*t = t_backup;
return;
}
if (!dry_run)
cpi->skip_false_count[mb_skip_context] += skip_inc;
switch (mbmi->txfm_size) {
case TX_32X32:
for (b = 0; b < 256; b += 64)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_32X32, dry_run);
for (b = 256; b < 384; b += 64)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_32X32, dry_run);
break;
case TX_16X16:
for (b = 0; b < 256; b += 16)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_16X16, dry_run);
for (b = 256; b < 384; b += 16)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_16X16, dry_run);
break;
case TX_8X8:
for (b = 0; b < 256; b += 4)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_8X8, dry_run);
for (b = 256; b < 384; b += 4)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_8X8, dry_run);
break;
case TX_4X4:
for (b = 0; b < 256; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
TX_4X4, dry_run);
for (b = 256; b < 384; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
TX_4X4, dry_run);
break;
default: assert(0);
}
if (dry_run)
*t = t_backup;
}
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;
switch (tx_size) {
case TX_16X16:
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(xd);
break;
case TX_8X8:
if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
xd->mode_info_context->mbmi.mode == SPLITMV)
xd->mode_info_context->mbmi.mb_skip_coeff =
mb_is_skippable_8x8_4x4uv(xd);
else
xd->mode_info_context->mbmi.mb_skip_coeff =
mb_is_skippable_8x8(xd);
break;
default:
xd->mode_info_context->mbmi.mb_skip_coeff =
mb_is_skippable_4x4(xd);
break;
}
if (xd->mode_info_context->mbmi.mb_skip_coeff) {
if (!dry_run)
cpi->skip_true_count[mb_skip_context] += skip_inc;
if (!cpi->common.mb_no_coeff_skip) {
vp9_stuff_mb(cpi, xd, t, dry_run);
} else {
vp9_reset_mb_tokens_context(xd);
}
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, dry_run);
for (b = 16; b < 24; b += 4) {
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, 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, 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, dry_run);
}
} else {
for (b = 16; b < 24; b += 4) {
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
}
}
} else {
for (b = 0; b < 16; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
for (b = 16; b < 24; b++)
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, 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_4x4, 0, sizeof(context_counters_4x4));
vpx_memset(context_counters_8x8, 0, sizeof(context_counters_8x8));
vpx_memset(context_counters_16x16, 0, sizeof(context_counters_16x16));
vpx_memset(context_counters_32x32, 0, sizeof(context_counters_32x32));
} else {
fread(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
fread(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
fread(context_counters_16x16, sizeof(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_4x4, 0, sizeof(tree_update_hist_4x4));
vpx_memset(tree_update_hist_8x8, 0, sizeof(tree_update_hist_8x8));
vpx_memset(tree_update_hist_16x16, 0, sizeof(tree_update_hist_16x16));
vpx_memset(tree_update_hist_32x32, 0, sizeof(tree_update_hist_32x32));
} else {
fread(tree_update_hist_4x4, sizeof(tree_update_hist_4x4), 1, f);
fread(tree_update_hist_8x8, sizeof(tree_update_hist_8x8), 1, f);
fread(tree_update_hist_16x16, sizeof(tree_update_hist_16x16), 1, f);
fread(tree_update_hist_32x32, sizeof(tree_update_hist_32x32), 1, f);
fclose(f);
}
}
static void print_counter(FILE *f, vp9_coeff_accum *context_counters,
int block_types, const char *header) {
int type, ref, band, pt, t;
fprintf(f, "static const vp9_coeff_count %s = {\n", header);
#define Comma(X) (X ? "," : "")
type = 0;
do {
ref = 0;
fprintf(f, "%s\n { /* block Type %d */", Comma(type), type);
do {
fprintf(f, "%s\n { /* %s */", Comma(type), ref ? "Inter" : "Intra");
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_t x = context_counters[type][ref][band][pt][t];
const int y = (int) x;
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 (++ref < REF_TYPES);
fprintf(f, "\n }");
} while (++type < block_types);
fprintf(f, "\n};\n");
}
static void print_probs(FILE *f, vp9_coeff_accum *context_counters,
int block_types, const char *header) {
int type, ref, band, pt, t;
fprintf(f, "static const vp9_coeff_probs %s = {", header);
type = 0;
#define Newline(x, spaces) (x ? " " : "\n" spaces)
do {
fprintf(f, "%s%s{ /* block Type %d */",
Comma(type), Newline(type, " "), type);
ref = 0;
do {
fprintf(f, "%s%s{ /* %s */",
Comma(band), Newline(band, " "), ref ? "Inter" : "Intra");
band = 0;
do {
fprintf(f, "%s%s{ /* Coeff Band %d */",
Comma(band), Newline(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[type][ref][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 %3d", 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 (++ref < REF_TYPES);
fprintf(f, "\n }");
} while (++type < block_types);
fprintf(f, "\n};\n");
}
void print_context_counters() {
FILE *f = fopen("vp9_context.c", "w");
fprintf(f, "#include \"vp9_entropy.h\"\n");
fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n");
/* print counts */
print_counter(f, context_counters_4x4, BLOCK_TYPES,
"vp9_default_coef_counts_4x4[BLOCK_TYPES]");
print_counter(f, context_counters_8x8, BLOCK_TYPES,
"vp9_default_coef_counts_8x8[BLOCK_TYPES]");
print_counter(f, context_counters_16x16, BLOCK_TYPES,
"vp9_default_coef_counts_16x16[BLOCK_TYPES]");
print_counter(f, context_counters_32x32, BLOCK_TYPES,
"vp9_default_coef_counts_32x32[BLOCK_TYPES]");
/* print coefficient probabilities */
print_probs(f, context_counters_4x4, BLOCK_TYPES,
"default_coef_probs_4x4[BLOCK_TYPES]");
print_probs(f, context_counters_8x8, BLOCK_TYPES,
"default_coef_probs_8x8[BLOCK_TYPES]");
print_probs(f, context_counters_16x16, BLOCK_TYPES,
"default_coef_probs_16x16[BLOCK_TYPES]");
print_probs(f, context_counters_32x32, BLOCK_TYPES,
"default_coef_probs_32x32[BLOCK_TYPES]");
fclose(f);
f = fopen("context.bin", "wb");
fwrite(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
fwrite(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
fwrite(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
fwrite(context_counters_32x32, sizeof(context_counters_32x32), 1, f);
fclose(f);
}
#endif
void vp9_tokenize_initialize() {
fill_value_tokens();
}
static void stuff_b(VP9_COMP *cpi,
MACROBLOCKD *xd,
const int ib,
TOKENEXTRA **tp,
PLANE_TYPE type,
TX_SIZE tx_size,
int dry_run) {
vp9_coeff_count *counts;
vp9_coeff_probs *probs;
int pt, band;
TOKENEXTRA *t = *tp;
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
const int ref = mbmi->ref_frame != INTRA_FRAME;
const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
if (sb_type == BLOCK_SIZE_SB32X32) {
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_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 = l2 = a3 = l3 = NULL;
} else {
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;
}
switch (tx_size) {
default:
case TX_4X4:
a_ec = a[0];
l_ec = l[0];
counts = cpi->coef_counts_4x4;
probs = cpi->common.fc.coef_probs_4x4;
break;
case TX_8X8:
a_ec = (a[0] + a[1]) != 0;
l_ec = (l[0] + l[1]) != 0;
counts = cpi->coef_counts_8x8;
probs = cpi->common.fc.coef_probs_8x8;
break;
case TX_16X16:
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;
}
counts = cpi->coef_counts_16x16;
probs = cpi->common.fc.coef_probs_16x16;
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;
}
counts = cpi->coef_counts_32x32;
probs = cpi->common.fc.coef_probs_32x32;
break;
}
VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec);
band = get_coef_band(tx_size, 0);
t->Token = DCT_EOB_TOKEN;
t->context_tree = probs[type][ref][band][pt];
t->skip_eob_node = 0;
++t;
*tp = t;
*a = *l = 0;
if (tx_size == TX_8X8) {
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) {
if (type != PLANE_TYPE_Y_WITH_DC) {
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;
}
}
if (!dry_run) {
++counts[type][ref][band][pt][DCT_EOB_TOKEN];
}
}
static void stuff_mb_8x8(VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run) {
int b;
for (b = 0; b < 16; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
for (b = 16; b < 24; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
}
static void stuff_mb_16x16(VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run) {
int b;
stuff_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
for (b = 16; b < 24; b += 4) {
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
}
}
static void stuff_mb_4x4(VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run) {
int b;
for (b = 0; b < 16; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
for (b = 16; b < 24; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
}
static void stuff_mb_8x8_4x4uv(VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run) {
int b;
for (b = 0; b < 16; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
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) {
TX_SIZE tx_size = xd->mode_info_context->mbmi.txfm_size;
TOKENEXTRA * const t_backup = *t;
if (tx_size == TX_16X16) {
stuff_mb_16x16(cpi, xd, t, dry_run);
} else if (tx_size == TX_8X8) {
if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
xd->mode_info_context->mbmi.mode == SPLITMV) {
stuff_mb_8x8_4x4uv(cpi, xd, t, dry_run);
} else {
stuff_mb_8x8(cpi, xd, t, dry_run);
}
} else {
stuff_mb_4x4(cpi, xd, t, dry_run);
}
if (dry_run) {
*t = t_backup;
}
}
void vp9_stuff_sb(VP9_COMP *cpi, MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run) {
TOKENEXTRA * const t_backup = *t;
int b;
switch (xd->mode_info_context->mbmi.txfm_size) {
case TX_32X32:
stuff_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_32X32, dry_run);
for (b = 64; b < 96; b += 16)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run);
break;
case TX_16X16:
for (b = 0; b < 64; b += 16)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
for (b = 64; b < 96; b += 16)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run);
break;
case TX_8X8:
for (b = 0; b < 64; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
for (b = 64; b < 96; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
break;
case TX_4X4:
for (b = 0; b < 64; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
for (b = 64; b < 96; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
break;
default: assert(0);
}
if (dry_run) {
*t = t_backup;
}
}
void vp9_stuff_sb64(VP9_COMP *cpi, MACROBLOCKD *xd,
TOKENEXTRA **t, int dry_run) {
TOKENEXTRA * const t_backup = *t;
int b;
switch (xd->mode_info_context->mbmi.txfm_size) {
case TX_32X32:
for (b = 0; b < 256; b += 64)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_32X32, dry_run);
for (b = 256; b < 384; b += 64)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_32X32, dry_run);
break;
case TX_16X16:
for (b = 0; b < 256; b += 16)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
for (b = 256; b < 384; b += 16)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run);
break;
case TX_8X8:
for (b = 0; b < 256; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
for (b = 256; b < 384; b += 4)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
break;
case TX_4X4:
for (b = 0; b < 256; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
for (b = 256; b < 384; b++)
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
break;
default: assert(0);
}
if (dry_run) {
*t = t_backup;
}
}
Reference in New Issue View Git Blame Copy Permalink