2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include "onyx_int.h"
|
|
|
|
#include "tokenize.h"
|
|
|
|
#include "vpx_mem/vpx_mem.h"
|
|
|
|
|
2012-03-19 19:02:04 +01:00
|
|
|
#include "vp8/common/pred_common.h"
|
2011-10-05 12:26:00 +02:00
|
|
|
#include "vp8/common/seg_common.h"
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
/* Global event counters used for accumulating statistics across several
|
|
|
|
compressions, then generating context.c = initial stats. */
|
|
|
|
|
|
|
|
#ifdef ENTROPY_STATS
|
2012-03-19 19:02:04 +01:00
|
|
|
INT64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
|
2012-05-02 22:53:15 +02:00
|
|
|
INT64 context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
INT64 context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
|
|
|
|
#endif
|
|
|
|
extern unsigned int 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];
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
extern unsigned int tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS]
|
|
|
|
[PREV_COEF_CONTEXTS][ENTROPY_NODES] [2];
|
|
|
|
#endif
|
2011-02-14 23:18:18 +01:00
|
|
|
#endif
|
2012-08-06 19:51:20 +02:00
|
|
|
void vp8_stuff_mb(VP8_COMP *cpi,
|
2012-08-15 12:00:53 +02:00
|
|
|
MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
|
2012-08-06 19:51:20 +02:00
|
|
|
void vp8_stuff_mb_8x8(VP8_COMP *cpi,
|
2012-08-15 12:00:53 +02:00
|
|
|
MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
|
2012-09-12 04:36:28 +02:00
|
|
|
void vp8_stuff_mb_8x8_4x4uv(VP8_COMP *cpi,
|
|
|
|
MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-15 12:00:53 +02:00
|
|
|
void vp8_stuff_mb_16x16(VP8_COMP *cpi, MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t, int dry_run);
|
2012-08-03 02:03:14 +02:00
|
|
|
#endif
|
2012-08-15 12:00:53 +02:00
|
|
|
void vp8_fix_contexts(MACROBLOCKD *xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2];
|
2010-09-16 16:00:04 +02:00
|
|
|
const TOKENVALUE *vp8_dct_value_tokens_ptr;
|
2012-07-14 00:21:29 +02:00
|
|
|
static int dct_value_cost[DCT_MAX_VALUE * 2];
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
const int *vp8_dct_value_cost_ptr;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void fill_value_tokens() {
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
TOKENVALUE *const t = dct_value_tokens + DCT_MAX_VALUE;
|
|
|
|
vp8_extra_bit_struct *const e = vp8_extra_bits;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int i = -DCT_MAX_VALUE;
|
|
|
|
int sign = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
|
|
|
if (!i)
|
|
|
|
sign = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
const int a = sign ? -i : i;
|
|
|
|
int eb = sign;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (a > 4) {
|
|
|
|
int j = 4;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
while (++j < 11 && e[j].base_val <= a) {}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t[i].Token = --j;
|
|
|
|
eb |= (a - e[j].base_val) << 1;
|
|
|
|
} else
|
|
|
|
t[i].Token = a;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t[i].Extra = eb;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// initialize the cost for extra bits for all possible coefficient value.
|
|
|
|
{
|
|
|
|
int cost = 0;
|
|
|
|
vp8_extra_bit_struct *p = vp8_extra_bits + t[i].Token;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (p->base_val) {
|
|
|
|
const int extra = t[i].Extra;
|
|
|
|
const int Length = p->Len;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (Length)
|
|
|
|
cost += vp8_treed_cost(p->tree, p->prob, extra >> 1, Length);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cost += vp8_cost_bit(vp8_prob_half, extra & 1); /* sign */
|
|
|
|
dct_value_cost[i + DCT_MAX_VALUE] = cost;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
} while (++i < DCT_MAX_VALUE);
|
|
|
|
|
|
|
|
vp8_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE;
|
|
|
|
vp8_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-06 19:51:20 +02:00
|
|
|
static void tokenize1st_order_b_16x16(MACROBLOCKD *xd,
|
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type,
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-08-03 02:03:14 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c = 0; /* start at DC unless type 0 */
|
|
|
|
const int eob = b->eob; /* one beyond last nonzero coeff */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
int x;
|
|
|
|
const short *qcoeff_ptr = b->qcoeff;
|
|
|
|
|
|
|
|
int seg_eob = 256;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB))
|
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
do {
|
|
|
|
const int band = vp8_coef_bands_16x16[c];
|
|
|
|
int v;
|
|
|
|
|
|
|
|
x = DCT_EOB_TOKEN;
|
|
|
|
if (c < eob) {
|
|
|
|
int rc = vp8_default_zig_zag1d_16x16[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
assert(-DCT_MAX_VALUE <= v && v < (DCT_MAX_VALUE));
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
x = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
}
|
|
|
|
|
|
|
|
t->Token = x;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_16x16[type][band][pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_16x16[type][band][pt][x];
|
2012-08-03 02:03:14 +02:00
|
|
|
} while (pt = vp8_prev_token_class[x], ++t, c < eob && ++c < seg_eob);
|
|
|
|
|
|
|
|
*tp = t;
|
|
|
|
pt = (c != !type); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
static void tokenize2nd_order_b_8x8
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd,
|
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c = 0; /* start at DC */
|
|
|
|
const int eob = b->eob; /* one beyond last nonzero coeff */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
int x;
|
|
|
|
const short *qcoeff_ptr = b->qcoeff;
|
|
|
|
|
|
|
|
int seg_eob = 4;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB)) {
|
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
}
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
assert(eob <= 4);
|
|
|
|
|
|
|
|
do {
|
|
|
|
const int band = vp8_coef_bands[c];
|
|
|
|
int v = 0;
|
|
|
|
|
|
|
|
if (c < eob) {
|
|
|
|
int rc = vp8_default_zig_zag1d[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
assert(-DCT_MAX_VALUE <= v && v < (DCT_MAX_VALUE));
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
x = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
} else
|
|
|
|
x = DCT_EOB_TOKEN;
|
|
|
|
|
|
|
|
t->Token = x;
|
|
|
|
// printf("Token : %d\n", x);
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8 [type] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8 [type] [band] [pt] [x];
|
2012-07-14 00:21:29 +02:00
|
|
|
} while (pt = vp8_prev_token_class[x], ++t, c < eob && ++c < seg_eob);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-03-19 19:02:04 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
*tp = t;
|
|
|
|
pt = (c != !type); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
static void tokenize2nd_order_b(MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c; /* start at DC */
|
|
|
|
TOKENEXTRA *t = *tp;/* store tokens starting here */
|
|
|
|
const BLOCKD *b;
|
|
|
|
const short *qcoeff_ptr;
|
|
|
|
ENTROPY_CONTEXT *a;
|
|
|
|
ENTROPY_CONTEXT *l;
|
|
|
|
int band, rc, v, token;
|
|
|
|
|
|
|
|
int seg_eob = 16;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB))
|
2012-07-14 00:21:29 +02:00
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
|
|
|
|
b = xd->block + 24;
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + 8;
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + 8;
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
for (c = 0; c < b->eob; c++) {
|
|
|
|
rc = vp8_default_zig_zag1d[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
|
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [1] [band] [pt] [token];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt];
|
2011-10-05 12:26:00 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [1] [band] [pt] [DCT_EOB_TOKEN];
|
2010-12-13 23:11:48 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t++;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
*tp = t;
|
|
|
|
pt = (c != 0); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
}
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
static void tokenize1st_order_b_8x8
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd,
|
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c = type ? 0 : 1; /* start at DC unless type 0 */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
const short *qcoeff_ptr = b->qcoeff;
|
|
|
|
|
|
|
|
int seg_eob = 64;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB))
|
2012-07-14 00:21:29 +02:00
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
for (; c < b->eob; ++c) {
|
2012-07-14 00:21:29 +02:00
|
|
|
const int band = vp8_coef_bands_8x8[c];
|
2012-07-23 23:58:07 +02:00
|
|
|
int rc = vp8_default_zig_zag1d_8x8[c];
|
|
|
|
int v = qcoeff_ptr[rc], x;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
assert(-DCT_MAX_VALUE <= v && v < (DCT_MAX_VALUE));
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
x = vp8_dct_value_tokens_ptr[v].Token;
|
Improved coding using 8x8 transform
In summary, this commit encompasses a series of changes in attempt to
improve the 8x8 transform based coding to help overall compression
quality, please refer to the detailed commit history below for what
are the rationale underly the series of changes:
a. A frame level flag to indicate if 8x8 transform is used at all.
b. 8x8 transform is not used for key frames and small image size.
c. On inter coded frame, macroblocks using modes B_PRED, SPLIT_MV
and I8X8_PRED are forced to using 4x4 transform based coding, the
rest uses 8x8 transform based coding.
d. Encoder and decoder has the same assumption on the relationship
between prediction modes and transform size, therefore no signaling
is encoded in bitstream.
e. Mode decision process now calculate the rate and distortion scores
using their respective transforms.
Overall test results:
1. HD set
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120206.html
(avg psnr: 3.09% glb psnr: 3.22%, ssim: 3.90%)
2. Cif set:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120206.html
(avg psnr: -0.03%, glb psnr: -0.02%, ssim: -0.04%)
It should be noted here, as 8x8 transform coding itself is disabled
for cif size clips, the 0.03% loss is purely from the 1 bit/frame
flag overhead on if 8x8 transform is used or not for the frame.
---patch history for future reference---
Patch 1:
this commit tries to select transform size based on macroblock
prediction mode. If the size of a prediction mode is 16x16, then
the macroblock is forced to use 8x8 transform. If the prediction
mode is B_PRED, SPLITMV or I8X8_PRED, then the macroblock is forced
to use 4x4 transform. Tests on the following HD clips showed mixed
results: (all hd clips only used first 100 frames in the test)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_log.html
while the results are mixed and overall negative, it is interesting to
see 8x8 helped a few of the clips.
Patch 2:
this patch tries to hard-wire selection of transform size based on
prediction modes without using segmentation to signal the transform size.
encoder and decoder both takes the same assumption that all macroblocks
use 8x8 transform except when prediciton mode is B_PRED, I8X8_PRED or
SPLITMV. Test results are as follows:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cifmodebase8x8_0125.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_0125log.html
Interestingly, by removing the overhead or coding the segmentation, the
results on this limited HD set have turn positive on average.
Patch 3:
this patch disabled the usage of 8x8 transform on key frames, and kept the
logic from patch 2 for inter frames only. test results on HD set turned
decidedly positive with 8x8 transform enabled on inter frame with 16x16
prediction modes: (avg psnr: .81% glb psnr: .82 ssim: .55%)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdintermode8x8_0125.html
results on cif set still negative overall
Patch 4:
continued from last patch, but now in mode decision process, the rate and
distortion estimates are computed based on 8x8 transform results for MBs
with modes associated with 8x8 transform. This patch also fixed a problem
related to segment based eob coding when 8x8 transform is used. The patch
significantly improved the results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hd8x8RDintermode.html
(avg psnr: 2.70% glb psnr: 2.76% ssim: 3.34%)
results on cif also improved, though they are still negative compared to
baseline that uses 4x4 transform only:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif8x8RDintermode.html
(avg psnr: -.78% glb psnr: -.86% ssim: -.19%)
Patch 5:
This patch does 3 things:
a. a bunch of decoder bug fixes, encodings and decodings were verified
to have matched recon buffer on a number of encodes on cif size mobile and
hd version of _pedestrian.
b. the patch further improved the rate distortion calculation of MBS that
use 8x8 transform. This provided some further gain on compression.
c. the patch also got the experimental work SEG_LVL_EOB to work with 8x8
transformed macroblock, test results indicates it improves the cif set
but hurt the HD set slightly.
Tests results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120201.html
(avg psnr: 3.19% glb psnr: 3.30% ssim: 3.93%)
Test results on cif clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120201.html
(avg psnr: -.47% glb psnr: -.51% ssim: +.28%)
Patch 6:
Added a frame level flag to indicate if 8x8 transform is allowed at all.
temporarily the decision is based on frame size, can be optimized later
one. This get the cif results to basically unchanged, with one bit per
frame overhead on both cif and hd clips.
Patch 8:
Rebase and Merge to head by PGW.
Fixed some suspect 4s that look like hey should be 64s in regard
to segmented EOB. Perhaps #defines would be bette.
Bulit and tested without T8x8 enabled and produces unchanged
output.
Patch 9:
Corrected misalligned code/decode of "txfm_mode" bit.
Limited testing for correct encode and decode with
T8x8 configured on derf clips.
Change-Id: I156e1405d25f81579d579dff8ab9af53944ec49c
2012-02-10 01:12:23 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->Token = x;
|
2012-07-23 23:58:07 +02:00
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8[type][band][pt];
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
|
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8[type][band][pt][x];
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
pt = vp8_prev_token_class[x];
|
|
|
|
++t;
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-23 23:58:07 +02:00
|
|
|
if (c < seg_eob) {
|
|
|
|
const int band = vp8_coef_bands_8x8[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8 [type] [band] [pt];
|
|
|
|
t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN];
|
2012-07-23 23:58:07 +02:00
|
|
|
++t;
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
*tp = t;
|
|
|
|
pt = (c != !type); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
|
|
|
|
2012-06-25 21:26:09 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM
|
|
|
|
static void tokenize1st_order_ht( MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int type,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-06-25 21:26:09 +02:00
|
|
|
unsigned int block;
|
|
|
|
const BLOCKD *b;
|
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c;
|
|
|
|
int token;
|
|
|
|
TOKENEXTRA *t = *tp;/* store tokens starting here */
|
|
|
|
const short *qcoeff_ptr;
|
|
|
|
ENTROPY_CONTEXT * a;
|
|
|
|
ENTROPY_CONTEXT * l;
|
|
|
|
int band, rc, v;
|
|
|
|
int tmp1, tmp2;
|
|
|
|
|
|
|
|
int const *pt_scan ;
|
|
|
|
|
|
|
|
int seg_eob = 16;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
if ( segfeature_active( xd, segment_id, SEG_LVL_EOB ) ) {
|
|
|
|
seg_eob = get_segdata( xd, segment_id, SEG_LVL_EOB );
|
|
|
|
}
|
|
|
|
|
|
|
|
b = xd->block;
|
|
|
|
|
|
|
|
/* Luma */
|
|
|
|
for (block = 0; block < 16; block++, b++) {
|
|
|
|
B_PREDICTION_MODE b_mode;
|
|
|
|
|
|
|
|
if( xd->mode_info_context->mbmi.mode == B_PRED ) {
|
|
|
|
b_mode = b->bmi.as_mode.first;
|
|
|
|
}
|
|
|
|
|
|
|
|
// assign scanning order for luma components coded in intra4x4 mode
|
2012-08-01 19:18:25 +02:00
|
|
|
if( (xd->mode_info_context->mbmi.mode == B_PRED) &&
|
|
|
|
(type == PLANE_TYPE_Y_WITH_DC) ) {
|
2012-06-25 21:26:09 +02:00
|
|
|
switch(b_mode) {
|
|
|
|
case B_VE_PRED :
|
|
|
|
case B_VR_PRED :
|
|
|
|
pt_scan = vp8_row_scan;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case B_HE_PRED :
|
|
|
|
case B_HD_PRED :
|
|
|
|
case B_HU_PRED :
|
|
|
|
pt_scan = vp8_col_scan;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default :
|
|
|
|
pt_scan = vp8_default_zig_zag1d;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pt_scan = vp8_default_zig_zag1d;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp1 = vp8_block2above[block];
|
|
|
|
tmp2 = vp8_block2left[block];
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + tmp1;
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + tmp2;
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
c = type ? 0 : 1;
|
|
|
|
|
|
|
|
for (; c < b->eob; c++) {
|
|
|
|
rc = pt_scan[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
|
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = pt == 0 &&
|
|
|
|
((band > 0 && type > 0) || (band > 1 && type == 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [type] [band] [pt] [token];
|
2012-06-25 21:26:09 +02:00
|
|
|
|
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = pt == 0 &&
|
|
|
|
((band > 0 && type > 0) || (band > 1 && type == 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN];
|
2012-06-25 21:26:09 +02:00
|
|
|
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tp = t;
|
|
|
|
pt = (c != !type); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
|
|
|
|
|
|
|
// reset scanning order for chroma components
|
|
|
|
pt_scan = vp8_default_zig_zag1d ;
|
|
|
|
|
|
|
|
/* Chroma */
|
|
|
|
for (block = 16; block < 24; block++, b++) {
|
|
|
|
tmp1 = vp8_block2above[block];
|
|
|
|
tmp2 = vp8_block2left[block];
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + tmp1;
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + tmp2;
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
for (c = 0; c < b->eob; c++) {
|
|
|
|
rc = pt_scan[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
|
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [token];
|
2012-06-25 21:26:09 +02:00
|
|
|
|
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [DCT_EOB_TOKEN];
|
2012-06-25 21:26:09 +02:00
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tp = t;
|
|
|
|
pt = (c != 0); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-01 19:18:25 +02:00
|
|
|
|
2012-08-02 18:07:33 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
2012-08-01 19:18:25 +02:00
|
|
|
static void tokenize1st_order_chroma
|
|
|
|
(
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-08-01 19:18:25 +02:00
|
|
|
unsigned int block;
|
|
|
|
const BLOCKD *b;
|
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
int c;
|
|
|
|
int token;
|
|
|
|
TOKENEXTRA *t = *tp;/* store tokens starting here */
|
|
|
|
const short *qcoeff_ptr;
|
|
|
|
ENTROPY_CONTEXT *a;
|
|
|
|
ENTROPY_CONTEXT *l;
|
|
|
|
int band, rc, v;
|
|
|
|
int tmp1, tmp2;
|
|
|
|
|
|
|
|
int seg_eob = 16;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB)) {
|
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
}
|
|
|
|
|
|
|
|
b = xd->block;
|
|
|
|
b += 16;
|
|
|
|
|
|
|
|
/* Chroma */
|
|
|
|
for (block = 16; block < 24; block++, b++) {
|
|
|
|
tmp1 = vp8_block2above[block];
|
|
|
|
tmp2 = vp8_block2left[block];
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + tmp1;
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + tmp2;
|
|
|
|
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
for (c = 0; c < b->eob; c++) {
|
|
|
|
rc = vp8_default_zig_zag1d[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
|
|
|
|
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
|
|
|
|
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [token];
|
2012-08-01 19:18:25 +02:00
|
|
|
|
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
|
|
|
|
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [DCT_EOB_TOKEN];
|
2012-08-01 19:18:25 +02:00
|
|
|
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
*tp = t;
|
|
|
|
pt = (c != 0); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
static void tokenize1st_order_b
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int block;
|
|
|
|
const BLOCKD *b;
|
|
|
|
int pt; /* near block/prev token context index */
|
2012-08-03 02:03:14 +02:00
|
|
|
int band, rc, v, c, token;
|
2012-07-14 00:21:29 +02:00
|
|
|
TOKENEXTRA *t = *tp;/* store tokens starting here */
|
|
|
|
const short *qcoeff_ptr;
|
2012-08-03 02:03:14 +02:00
|
|
|
ENTROPY_CONTEXT *a, *l;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
int seg_eob = 16;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_EOB)) {
|
|
|
|
seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
|
|
|
|
}
|
|
|
|
|
|
|
|
b = xd->block;
|
|
|
|
/* Luma */
|
|
|
|
for (block = 0; block < 16; block++, b++) {
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
2012-08-03 02:03:14 +02:00
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + vp8_block2above[block];
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + vp8_block2left[block];
|
2012-07-14 00:21:29 +02:00
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
c = type ? 0 : 1;
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (; c < b->eob; c++) {
|
|
|
|
rc = vp8_default_zig_zag1d[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = pt == 0 &&
|
|
|
|
((band > 0 && type > 0) || (band > 1 && type == 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [type] [band] [pt] [token];
|
2011-10-05 12:26:00 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
|
2010-12-13 23:11:48 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = pt == 0 &&
|
|
|
|
((band > 0 && type > 0) || (band > 1 && type == 0));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t++;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
*tp = t;
|
|
|
|
pt = (c != !type); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
/* Chroma */
|
|
|
|
for (block = 16; block < 24; block++, b++) {
|
|
|
|
qcoeff_ptr = b->qcoeff;
|
2012-08-03 02:03:14 +02:00
|
|
|
a = (ENTROPY_CONTEXT *)xd->above_context + vp8_block2above[block];
|
|
|
|
l = (ENTROPY_CONTEXT *)xd->left_context + vp8_block2left[block];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (c = 0; c < b->eob; c++) {
|
|
|
|
rc = vp8_default_zig_zag1d[c];
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
v = qcoeff_ptr[rc];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->Extra = vp8_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp8_dct_value_tokens_ptr[v].Token;
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->Token = token;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [token];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
pt = vp8_prev_token_class[token];
|
|
|
|
t++;
|
|
|
|
}
|
2012-02-09 18:06:52 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (c < seg_eob) {
|
|
|
|
band = vp8_coef_bands[c];
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t->skip_eob_node = ((pt == 0) && (band > 0));
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [2] [band] [pt] [DCT_EOB_TOKEN];
|
2011-07-11 14:55:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t++;
|
2011-07-11 14:55:45 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
*tp = t;
|
|
|
|
pt = (c != 0); /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2010-10-07 07:39:16 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
int mby_is_skippable(MACROBLOCKD *xd, int has_y2_block) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int skip = 1;
|
|
|
|
int i = 0;
|
2010-10-07 07:39:16 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (has_y2_block) {
|
|
|
|
for (i = 0; i < 16; i++)
|
2012-08-15 12:00:53 +02:00
|
|
|
skip &= (xd->block[i].eob < 2);
|
|
|
|
skip &= (!xd->block[24].eob);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
for (i = 0; i < 16; i++)
|
2012-08-15 12:00:53 +02:00
|
|
|
skip &= (!xd->block[i].eob);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
return skip;
|
2012-02-22 03:10:18 +01:00
|
|
|
}
|
2010-10-07 07:39:16 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
int mbuv_is_skippable(MACROBLOCKD *xd) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int skip = 1;
|
|
|
|
int i;
|
2010-10-07 07:39:16 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 16; i < 24; i++)
|
2012-08-15 12:00:53 +02:00
|
|
|
skip &= (!xd->block[i].eob);
|
2012-07-14 00:21:29 +02:00
|
|
|
return skip;
|
2010-10-07 07:39:16 +02:00
|
|
|
}
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
int mb_is_skippable(MACROBLOCKD *xd, int has_y2_block) {
|
|
|
|
return (mby_is_skippable(xd, has_y2_block) &
|
|
|
|
mbuv_is_skippable(xd));
|
2012-02-22 03:10:18 +01:00
|
|
|
}
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-09-12 04:36:28 +02:00
|
|
|
int mby_is_skippable_8x8(MACROBLOCKD *xd, int has_y2_block) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int skip = 1;
|
|
|
|
int i = 0;
|
2011-11-18 03:31:00 +01:00
|
|
|
|
2012-09-12 04:36:28 +02:00
|
|
|
if (has_y2_block) {
|
|
|
|
for (i = 0; i < 16; i += 4)
|
|
|
|
skip &= (xd->block[i].eob < 2);
|
|
|
|
skip &= (!xd->block[24].eob);
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < 16; i += 4)
|
|
|
|
skip &= (!xd->block[i].eob);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
return skip;
|
2012-02-22 03:10:18 +01:00
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
int mbuv_is_skippable_8x8(MACROBLOCKD *xd) {
|
|
|
|
return (!xd->block[16].eob) & (!xd->block[20].eob);
|
2012-02-22 03:10:18 +01:00
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-09-12 04:36:28 +02:00
|
|
|
int mb_is_skippable_8x8(MACROBLOCKD *xd, int has_y2_block) {
|
|
|
|
return (mby_is_skippable_8x8(xd, has_y2_block) &
|
|
|
|
mbuv_is_skippable_8x8(xd));
|
|
|
|
}
|
|
|
|
|
|
|
|
int mb_is_skippable_8x8_4x4uv(MACROBLOCKD *xd, int has_y2_block) {
|
|
|
|
return (mby_is_skippable_8x8(xd, has_y2_block) &
|
|
|
|
mbuv_is_skippable(xd));
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-15 12:00:53 +02:00
|
|
|
int mby_is_skippable_16x16(MACROBLOCKD *xd) {
|
2012-08-03 02:03:14 +02:00
|
|
|
int skip = 1;
|
2012-08-15 12:00:53 +02:00
|
|
|
//skip &= (xd->block[0].eob < 2); // I think this should be commented? No second order == DC must be coded
|
|
|
|
//skip &= (xd->block[0].eob < 1);
|
|
|
|
//skip &= (!xd->block[24].eob);
|
|
|
|
skip &= !xd->block[0].eob;
|
2012-08-03 02:03:14 +02:00
|
|
|
return skip;
|
|
|
|
}
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
int mb_is_skippable_16x16(MACROBLOCKD *xd) {
|
2012-08-15 18:43:36 +02:00
|
|
|
return (mby_is_skippable_16x16(xd) & mbuv_is_skippable_8x8(xd));
|
2012-08-03 02:03:14 +02:00
|
|
|
}
|
|
|
|
#endif
|
2010-10-07 07:39:16 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
void vp8_tokenize_mb(VP8_COMP *cpi,
|
2012-08-15 12:00:53 +02:00
|
|
|
MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int plane_type;
|
|
|
|
int has_y2_block;
|
|
|
|
int b;
|
2012-08-15 12:00:53 +02:00
|
|
|
int tx_type = xd->mode_info_context->mbmi.txfm_size;
|
|
|
|
int mb_skip_context = get_pred_context(&cpi->common, xd, PRED_MBSKIP);
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA *t_backup = *t;
|
2011-11-04 19:29:51 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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;
|
2012-08-15 12:00:53 +02:00
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
2011-10-28 16:27:23 +02:00
|
|
|
|
2012-06-25 21:26:09 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM
|
|
|
|
int QIndex = cpi->mb.q_index;
|
2012-08-01 19:18:25 +02:00
|
|
|
int active_ht = (QIndex < ACTIVE_HT) &&
|
2012-08-15 12:00:53 +02:00
|
|
|
(xd->mode_info_context->mbmi.mode == B_PRED);
|
2012-06-25 21:26:09 +02:00
|
|
|
#endif
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
if (!segfeature_active(xd, segment_id, SEG_LVL_EOB) ||
|
|
|
|
(get_segdata(xd, segment_id, SEG_LVL_EOB) != 0)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
skip_inc = 1;
|
|
|
|
} else
|
|
|
|
skip_inc = 0;
|
2011-10-28 16:27:23 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
has_y2_block = (xd->mode_info_context->mbmi.mode != B_PRED
|
|
|
|
&& xd->mode_info_context->mbmi.mode != I8X8_PRED
|
|
|
|
&& xd->mode_info_context->mbmi.mode != SPLITMV);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
if (tx_type == TX_16X16) has_y2_block = 0; // Because of inter frames
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
switch (tx_type) {
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
case TX_16X16:
|
2012-08-15 18:43:36 +02:00
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(xd);
|
2012-08-03 02:03:14 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case TX_8X8:
|
2012-09-12 04:36:28 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED)
|
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_8x8_4x4uv(xd, 0);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_8x8(xd, has_y2_block);
|
2012-08-03 02:03:14 +02:00
|
|
|
break;
|
2012-09-12 04:36:28 +02:00
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
default:
|
2012-08-15 12:00:53 +02:00
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(xd, has_y2_block);
|
2012-08-03 02:03:14 +02:00
|
|
|
break;
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mb_skip_coeff) {
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_true_count[mb_skip_context] += skip_inc;
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!cpi->common.mb_no_coeff_skip) {
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
if (tx_type == TX_16X16)
|
2012-08-15 18:43:36 +02:00
|
|
|
vp8_stuff_mb_16x16(cpi, xd, t, dry_run);
|
2012-08-03 02:03:14 +02:00
|
|
|
else
|
|
|
|
#endif
|
2012-09-12 04:36:28 +02:00
|
|
|
if (tx_type == TX_8X8) {
|
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED)
|
|
|
|
vp8_stuff_mb_8x8_4x4uv(cpi, xd, t, dry_run);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
vp8_stuff_mb_8x8(cpi, xd, t, dry_run);
|
|
|
|
} else
|
2012-08-15 12:00:53 +02:00
|
|
|
vp8_stuff_mb(cpi, xd, t, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-15 12:00:53 +02:00
|
|
|
vp8_fix_contexts(xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-08-06 19:51:20 +02:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2012-07-14 00:21:29 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_false_count[mb_skip_context] += skip_inc;
|
2011-04-21 20:38:36 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
plane_type = 3;
|
|
|
|
if (has_y2_block) {
|
|
|
|
if (tx_type == TX_8X8) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
|
|
|
|
tokenize2nd_order_b_8x8(xd,
|
|
|
|
xd->block + 24, t, 1, xd->frame_type,
|
2012-07-14 00:21:29 +02:00
|
|
|
A + vp8_block2above_8x8[24],
|
2012-08-06 19:51:20 +02:00
|
|
|
L + vp8_block2left_8x8[24],
|
|
|
|
cpi, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else
|
2012-08-15 12:00:53 +02:00
|
|
|
tokenize2nd_order_b(xd, t, cpi, dry_run);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
plane_type = 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
if (tx_type == TX_16X16) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context;
|
2012-08-29 20:25:38 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
tokenize1st_order_b_16x16(xd, xd->block, t, 3,
|
|
|
|
xd->frame_type, A, L, cpi, dry_run);
|
2012-08-29 20:25:38 +02:00
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
for (b = 1; b < 16; b++) {
|
|
|
|
*(A + vp8_block2above[b]) = *(A);
|
|
|
|
*(L + vp8_block2left[b] ) = *(L);
|
|
|
|
}
|
|
|
|
for (b = 16; b < 24; b += 4) {
|
2012-08-15 12:00:53 +02:00
|
|
|
tokenize1st_order_b_8x8(xd, xd->block + b, t, 2, xd->frame_type,
|
2012-08-06 19:51:20 +02:00
|
|
|
A + vp8_block2above_8x8[b], L + vp8_block2left_8x8[b], cpi, dry_run);
|
2012-08-03 02:03:14 +02:00
|
|
|
*(A + vp8_block2above_8x8[b]+1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b]+1 ) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
|
|
|
vpx_memset(&A[8], 0, sizeof(A[8]));
|
|
|
|
vpx_memset(&L[8], 0, sizeof(L[8]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (tx_type == TX_8X8) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
|
2012-09-12 04:36:28 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED) {
|
|
|
|
plane_type = PLANE_TYPE_Y_WITH_DC;
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
for (b = 0; b < 16; b += 4) {
|
2012-08-15 12:00:53 +02:00
|
|
|
tokenize1st_order_b_8x8(xd,
|
|
|
|
xd->block + b, t, plane_type, xd->frame_type,
|
2012-07-14 00:21:29 +02:00
|
|
|
A + vp8_block2above_8x8[b],
|
|
|
|
L + vp8_block2left_8x8[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
cpi, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
*(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b] + 1) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
2012-09-12 04:36:28 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED) {
|
|
|
|
tokenize1st_order_chroma(xd, t, PLANE_TYPE_UV, cpi, dry_run);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
for (b = 16; b < 24; b += 4) {
|
|
|
|
tokenize1st_order_b_8x8(xd,
|
|
|
|
xd->block + b, t, 2, xd->frame_type,
|
|
|
|
A + vp8_block2above_8x8[b],
|
|
|
|
L + vp8_block2left_8x8[b],
|
|
|
|
cpi, dry_run);
|
|
|
|
*(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b] + 1) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
2012-06-25 21:26:09 +02:00
|
|
|
} else {
|
|
|
|
#if CONFIG_HYBRIDTRANSFORM
|
2012-09-12 04:36:28 +02:00
|
|
|
if (active_ht)
|
2012-08-15 12:00:53 +02:00
|
|
|
tokenize1st_order_ht(xd, t, plane_type, cpi, dry_run);
|
2012-09-12 04:36:28 +02:00
|
|
|
else
|
2012-06-25 21:26:09 +02:00
|
|
|
#endif
|
2012-09-12 04:36:28 +02:00
|
|
|
tokenize1st_order_b(xd, t, plane_type, cpi, dry_run);
|
2012-06-25 21:26:09 +02:00
|
|
|
}
|
2012-09-12 04:36:28 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2010-08-31 16:49:57 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#ifdef ENTROPY_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
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_8x8, 0, sizeof(context_counters_8x8));
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
vpx_memset(context_counters_16x16, 0, sizeof(context_counters_16x16));
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
fread(context_counters, sizeof(context_counters), 1, f);
|
|
|
|
fread(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
fread(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
f = fopen("treeupdate.bin", "rb");
|
|
|
|
if (!f) {
|
|
|
|
vpx_memset(tree_update_hist, 0, sizeof(tree_update_hist));
|
|
|
|
vpx_memset(tree_update_hist_8x8, 0, sizeof(tree_update_hist_8x8));
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
vpx_memset(tree_update_hist_16x16, 0, sizeof(tree_update_hist_16x16));
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
fread(tree_update_hist, sizeof(tree_update_hist), 1, f);
|
|
|
|
fread(tree_update_hist_8x8, sizeof(tree_update_hist_8x8), 1, f);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
fread(tree_update_hist_16x16, sizeof(tree_update_hist_16x16), 1, f);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void print_context_counters() {
|
|
|
|
int type, band, pt, t;
|
|
|
|
FILE *f = fopen("context.c", "w");
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "#include \"entropy.h\"\n");
|
|
|
|
fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n");
|
|
|
|
fprintf(f, "static const unsigned int\n"
|
|
|
|
"vp8_default_coef_counts[BLOCK_TYPES]\n"
|
|
|
|
" [COEF_BANDS]\n"
|
|
|
|
" [PREV_COEF_CONTEXTS]\n"
|
|
|
|
" [MAX_ENTROPY_TOKENS]={\n");
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
# define Comma( X) (X? ",":"")
|
2012-07-14 00:21:29 +02:00
|
|
|
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 [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");
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "static const unsigned int\nvp8_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;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
assert(x == (INT64) y); /* no overflow handling yet */
|
|
|
|
fprintf(f, "%s %d", Comma(t), y);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
} while (++t < MAX_ENTROPY_TOKENS);
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "}");
|
|
|
|
} while (++pt < PREV_COEF_CONTEXTS);
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "\n }");
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
} while (++band < COEF_BANDS);
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "\n }");
|
|
|
|
} while (++type < BLOCK_TYPES_8X8);
|
2012-08-03 02:03:14 +02:00
|
|
|
fprintf(f, "\n};\n");
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
fprintf(f, "static const unsigned int\nvp8_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;
|
|
|
|
|
|
|
|
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_16X16);
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "\n};\n");
|
2012-08-03 02:03:14 +02:00
|
|
|
#endif
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "static const vp8_prob\n"
|
|
|
|
"vp8_default_coef_probs[BLOCK_TYPES] [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];
|
|
|
|
vp8_prob coef_probs[ENTROPY_NODES];
|
|
|
|
for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
|
|
|
|
coef_counts[t] = context_counters [type] [band] [pt] [t];
|
|
|
|
vp8_tree_probs_from_distribution(
|
|
|
|
MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
|
|
|
|
coef_probs, branch_ct, coef_counts, 256, 1);
|
|
|
|
fprintf(f, "%s\n {", Comma(pt));
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
t = 0;
|
|
|
|
do {
|
|
|
|
fprintf(f, "%s %d", Comma(t), coef_probs[t]);
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
} while (++t < ENTROPY_NODES);
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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");
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "static const vp8_prob\n"
|
|
|
|
"vp8_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];
|
|
|
|
vp8_prob coef_probs[ENTROPY_NODES];
|
|
|
|
for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
|
|
|
|
coef_counts[t] = context_counters_8x8[type] [band] [pt] [t];
|
|
|
|
vp8_tree_probs_from_distribution(
|
|
|
|
MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
|
|
|
|
coef_probs, branch_ct, coef_counts, 256, 1);
|
|
|
|
fprintf(f, "%s\n {", Comma(pt));
|
2012-03-21 23:22:21 +01:00
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
t = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
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");
|
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
fprintf(f, "static const vp8_prob\n"
|
|
|
|
"vp8_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];
|
|
|
|
vp8_prob coef_probs[ENTROPY_NODES];
|
|
|
|
for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
|
|
|
|
coef_counts[t] = context_counters_16x16[type] [band] [pt] [t];
|
|
|
|
vp8_tree_probs_from_distribution(
|
|
|
|
MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
|
|
|
|
coef_probs, branch_ct, coef_counts, 256, 1);
|
|
|
|
fprintf(f, "%s\n {", Comma(pt));
|
|
|
|
|
|
|
|
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");
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
f = fopen("context.bin", "wb");
|
|
|
|
fwrite(context_counters, sizeof(context_counters), 1, f);
|
|
|
|
fwrite(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
fwrite(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_tokenize_initialize() {
|
|
|
|
fill_value_tokens();
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
static __inline void stuff2nd_order_b_8x8(
|
2012-07-14 00:21:29 +02:00
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
(void) frametype;
|
|
|
|
(void) type;
|
|
|
|
(void) b;
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8 [1] [0] [pt];
|
|
|
|
// t->section = 11;
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8 [1] [0] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = 0;
|
|
|
|
*a = *l = pt;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void stuff1st_order_b_8x8
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
(void) frametype;
|
|
|
|
(void) type;
|
|
|
|
(void) b;
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8 [0] [1] [pt];
|
|
|
|
// t->section = 8;
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8[0] [1] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = 0; /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline
|
|
|
|
void stuff1st_order_buv_8x8
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
(void) frametype;
|
|
|
|
(void) type;
|
|
|
|
(void) b;
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_8x8 [2] [0] [pt];
|
|
|
|
// t->section = 13;
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_8x8[2] [0] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = 0; /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
void vp8_stuff_mb_8x8(VP8_COMP *cpi,
|
2012-08-15 12:00:53 +02:00
|
|
|
MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t,
|
|
|
|
int dry_run) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
|
2012-07-14 00:21:29 +02:00
|
|
|
int plane_type;
|
|
|
|
int b;
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA *t_backup = *t;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
stuff2nd_order_b_8x8(xd->block + 24, t, 1, xd->frame_type,
|
2012-07-14 00:21:29 +02:00
|
|
|
A + vp8_block2above_8x8[24],
|
2012-08-06 19:51:20 +02:00
|
|
|
L + vp8_block2left_8x8[24], cpi, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
plane_type = 0;
|
|
|
|
|
|
|
|
for (b = 0; b < 16; b += 4) {
|
2012-08-15 12:00:53 +02:00
|
|
|
stuff1st_order_b_8x8(xd->block + b, t, plane_type, xd->frame_type,
|
2012-07-14 00:21:29 +02:00
|
|
|
A + vp8_block2above_8x8[b],
|
|
|
|
L + vp8_block2left_8x8[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
cpi, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
*(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b] + 1) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (b = 16; b < 24; b += 4) {
|
2012-08-15 12:00:53 +02:00
|
|
|
stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
|
2012-07-14 00:21:29 +02:00
|
|
|
A + vp8_block2above[b],
|
|
|
|
L + vp8_block2left[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
cpi, dry_run);
|
2012-07-14 00:21:29 +02:00
|
|
|
*(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b] + 1) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
2012-08-06 19:51:20 +02:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
static __inline
|
2012-08-06 19:51:20 +02:00
|
|
|
void stuff1st_order_b_16x16(const BLOCKD *const b,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
const FRAME_TYPE frametype,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run){
|
2012-08-03 02:03:14 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
(void) frametype;
|
|
|
|
(void) b;
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs_16x16[3][1][pt];
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts_16x16[3][1][pt][DCT_EOB_TOKEN];
|
2012-08-03 02:03:14 +02:00
|
|
|
pt = 0; /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
|
|
|
}
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
void vp8_stuff_mb_16x16(VP8_COMP *cpi,
|
2012-08-15 12:00:53 +02:00
|
|
|
MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t,
|
|
|
|
int dry_run) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context;
|
2012-08-03 02:03:14 +02:00
|
|
|
int b, i;
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA *t_backup = *t;
|
2012-08-03 02:03:14 +02:00
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
stuff1st_order_b_16x16(xd->block, t, xd->frame_type, A, L, cpi, dry_run);
|
2012-08-03 02:03:14 +02:00
|
|
|
for (i = 1; i < 16; i++) {
|
|
|
|
*(A + vp8_block2above[i]) = *(A);
|
|
|
|
*(L + vp8_block2left[i]) = *(L);
|
|
|
|
}
|
|
|
|
for (b = 16; b < 24; b += 4) {
|
2012-08-15 12:00:53 +02:00
|
|
|
stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
|
2012-08-03 02:03:14 +02:00
|
|
|
A + vp8_block2above[b],
|
|
|
|
L + vp8_block2left[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
cpi, dry_run);
|
2012-08-03 02:03:14 +02:00
|
|
|
*(A + vp8_block2above_8x8[b]+1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b]+1 ) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
|
|
|
vpx_memset(&A[8], 0, sizeof(A[8]));
|
|
|
|
vpx_memset(&L[8], 0, sizeof(L[8]));
|
2012-08-06 19:51:20 +02:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2012-08-03 02:03:14 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
static __inline void stuff2nd_order_b
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
TOKENEXTRA **tp,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt];
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts [1] [0] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
pt = 0;
|
|
|
|
*a = *l = pt;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
static __inline void stuff1st_order_b(TOKENEXTRA **tp,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [0] [1] [pt];
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts[0] [1] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = 0; /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
static __inline
|
|
|
|
void stuff1st_order_buv
|
|
|
|
(
|
2012-07-14 00:21:29 +02:00
|
|
|
TOKENEXTRA **tp,
|
|
|
|
ENTROPY_CONTEXT *a,
|
|
|
|
ENTROPY_CONTEXT *l,
|
2012-08-06 19:51:20 +02:00
|
|
|
VP8_COMP *cpi,
|
|
|
|
int dry_run) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int pt; /* near block/prev token context index */
|
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
|
|
|
VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
|
|
|
|
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt];
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (!dry_run)
|
|
|
|
++cpi->coef_counts[2] [0] [pt] [DCT_EOB_TOKEN];
|
2012-07-14 00:21:29 +02:00
|
|
|
pt = 0; /* 0 <-> all coeff data is zero */
|
|
|
|
*a = *l = pt;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t, int dry_run) {
|
2012-08-15 12:00:53 +02:00
|
|
|
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
|
|
|
|
ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
|
2012-07-14 00:21:29 +02:00
|
|
|
int plane_type;
|
|
|
|
int b;
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA *t_backup = *t;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
stuff2nd_order_b(t,
|
2012-08-06 19:51:20 +02:00
|
|
|
A + vp8_block2above[24],
|
|
|
|
L + vp8_block2left[24],
|
|
|
|
cpi, dry_run);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (b = 0; b < 16; b++)
|
|
|
|
stuff1st_order_b(t,
|
|
|
|
A + vp8_block2above[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
L + vp8_block2left[b],
|
|
|
|
cpi, dry_run);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (b = 16; b < 24; b++)
|
|
|
|
stuff1st_order_buv(t,
|
|
|
|
A + vp8_block2above[b],
|
2012-08-06 19:51:20 +02:00
|
|
|
L + vp8_block2left[b],
|
|
|
|
cpi, dry_run);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-06 19:51:20 +02:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-09-12 04:36:28 +02:00
|
|
|
|
|
|
|
void vp8_stuff_mb_8x8_4x4uv(VP8_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 plane_type;
|
|
|
|
int b;
|
|
|
|
TOKENEXTRA *t_backup = *t;
|
|
|
|
|
|
|
|
stuff2nd_order_b_8x8(xd->block + 24, t, 1, xd->frame_type,
|
|
|
|
A + vp8_block2above_8x8[24],
|
|
|
|
L + vp8_block2left_8x8[24], cpi, dry_run);
|
|
|
|
plane_type = 3;
|
|
|
|
|
|
|
|
for (b = 0; b < 16; b += 4) {
|
|
|
|
stuff1st_order_b_8x8(xd->block + b, t, plane_type, xd->frame_type,
|
|
|
|
A + vp8_block2above_8x8[b],
|
|
|
|
L + vp8_block2left_8x8[b],
|
|
|
|
cpi, dry_run);
|
|
|
|
*(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
|
|
|
|
*(L + vp8_block2left_8x8[b] + 1) = *(L + vp8_block2left_8x8[b]);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (b = 16; b < 24; b++)
|
|
|
|
stuff1st_order_buv(t,
|
|
|
|
A + vp8_block2above[b],
|
|
|
|
L + vp8_block2left[b],
|
|
|
|
cpi, dry_run);
|
|
|
|
|
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
|
|
|
}
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
void vp8_fix_contexts(MACROBLOCKD *xd) {
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Clear entropy contexts for Y2 blocks */
|
2012-08-15 12:00:53 +02:00
|
|
|
if ((xd->mode_info_context->mbmi.mode != B_PRED
|
|
|
|
&& xd->mode_info_context->mbmi.mode != I8X8_PRED
|
|
|
|
&& xd->mode_info_context->mbmi.mode != SPLITMV)
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-15 12:00:53 +02:00
|
|
|
|| xd->mode_info_context->mbmi.txfm_size == TX_16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
#endif
|
|
|
|
) {
|
2012-08-15 12:00:53 +02:00
|
|
|
vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
|
|
|
|
vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-15 12:00:53 +02:00
|
|
|
vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
|
|
|
|
vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|