2010-05-18 19:58:33 +04:00
|
|
|
/*
|
2010-09-09 16:16:39 +04:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 19:58:33 +04:00
|
|
|
*
|
2010-06-18 20:39:21 +04:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-05 00:19:40 +04: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 20:39:21 +04:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-05 00:19:40 +04:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 19:58:33 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
2012-11-28 22:41:40 +04:00
|
|
|
#include "vp9/encoder/vp9_onyx_int.h"
|
|
|
|
#include "vp9/encoder/vp9_tokenize.h"
|
2010-05-18 19:58:33 +04:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
|
|
|
|
2012-11-28 01:59:17 +04:00
|
|
|
#include "vp9/common/vp9_pred_common.h"
|
|
|
|
#include "vp9/common/vp9_seg_common.h"
|
|
|
|
#include "vp9/common/vp9_entropy.h"
|
2011-10-05 14:26:00 +04:00
|
|
|
|
2010-05-18 19:58:33 +04:00
|
|
|
/* Global event counters used for accumulating statistics across several
|
2012-11-28 01:59:17 +04:00
|
|
|
compressions, then generating vp9_context.c = initial stats. */
|
2010-05-18 19:58:33 +04:00
|
|
|
|
|
|
|
#ifdef ENTROPY_STATS
|
2013-02-20 01:36:38 +04:00
|
|
|
vp9_coeff_accum context_counters_4x4[BLOCK_TYPES];
|
|
|
|
vp9_coeff_accum context_counters_8x8[BLOCK_TYPES];
|
|
|
|
vp9_coeff_accum context_counters_16x16[BLOCK_TYPES];
|
2013-03-05 02:12:17 +04:00
|
|
|
vp9_coeff_accum context_counters_32x32[BLOCK_TYPES];
|
2012-12-08 04:09:59 +04:00
|
|
|
|
2013-02-20 01:36:38 +04:00
|
|
|
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];
|
2013-03-05 02:12:17 +04:00
|
|
|
extern vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES];
|
2012-10-10 22:20:33 +04:00
|
|
|
#endif /* ENTROPY_STATS */
|
|
|
|
|
2013-03-08 08:56:34 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
#ifdef NZC_STATS
|
|
|
|
unsigned int nzc_counts_4x4[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
|
|
|
|
[NZC4X4_TOKENS];
|
|
|
|
unsigned int nzc_counts_8x8[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
|
|
|
|
[NZC8X8_TOKENS];
|
|
|
|
unsigned int nzc_counts_16x16[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
|
|
|
|
[NZC16X16_TOKENS];
|
|
|
|
unsigned int nzc_counts_32x32[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
|
|
|
|
[NZC32X32_TOKENS];
|
|
|
|
unsigned int nzc_pcat_counts[MAX_NZC_CONTEXTS][NZC_TOKENS_EXTRA]
|
|
|
|
[NZC_BITS_EXTRA][2];
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2];
|
2012-10-31 04:12:12 +04:00
|
|
|
const TOKENVALUE *vp9_dct_value_tokens_ptr;
|
2012-07-14 02:21:29 +04:00
|
|
|
static int dct_value_cost[DCT_MAX_VALUE * 2];
|
2012-10-31 04:12:12 +04:00
|
|
|
const int *vp9_dct_value_cost_ptr;
|
2011-02-15 01:18:18 +03:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
static void fill_value_tokens() {
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
TOKENVALUE *const t = dct_value_tokens + DCT_MAX_VALUE;
|
2012-11-01 01:40:53 +04:00
|
|
|
vp9_extra_bit_struct *const e = vp9_extra_bits;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
int i = -DCT_MAX_VALUE;
|
|
|
|
int sign = 1;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
|
|
|
if (!i)
|
|
|
|
sign = 0;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
{
|
|
|
|
const int a = sign ? -i : i;
|
|
|
|
int eb = sign;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (a > 4) {
|
|
|
|
int j = 4;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
while (++j < 11 && e[j].base_val <= a) {}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
t[i].Token = --j;
|
|
|
|
eb |= (a - e[j].base_val) << 1;
|
|
|
|
} else
|
|
|
|
t[i].Token = a;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
t[i].Extra = eb;
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
// initialize the cost for extra bits for all possible coefficient value.
|
|
|
|
{
|
|
|
|
int cost = 0;
|
2012-11-01 01:40:53 +04:00
|
|
|
vp9_extra_bit_struct *p = vp9_extra_bits + t[i].Token;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (p->base_val) {
|
|
|
|
const int extra = t[i].Extra;
|
|
|
|
const int Length = p->Len;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (Length)
|
2012-11-01 01:40:53 +04:00
|
|
|
cost += treed_cost(p->tree, p->prob, extra >> 1, Length);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-01 01:40:53 +04:00
|
|
|
cost += vp9_cost_bit(vp9_prob_half, extra & 1); /* sign */
|
2012-07-14 02:21:29 +04:00
|
|
|
dct_value_cost[i + DCT_MAX_VALUE] = cost;
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
} while (++i < DCT_MAX_VALUE);
|
|
|
|
|
2012-10-31 04:12:12 +04:00
|
|
|
vp9_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE;
|
|
|
|
vp9_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-11-28 03:51:06 +04:00
|
|
|
|
2013-03-27 03:46:09 +04:00
|
|
|
extern const int *vp9_get_coef_neighbors_handle(const int *scan, int *pad);
|
|
|
|
|
2012-10-31 04:53:32 +04:00
|
|
|
static void tokenize_b(VP9_COMP *cpi,
|
2012-10-25 20:14:21 +04:00
|
|
|
MACROBLOCKD *xd,
|
2012-12-07 00:40:57 +04:00
|
|
|
const int ib,
|
2012-10-25 20:14:21 +04:00
|
|
|
TOKENEXTRA **tp,
|
|
|
|
PLANE_TYPE type,
|
|
|
|
TX_SIZE tx_size,
|
2013-04-04 23:03:27 +04:00
|
|
|
int y_blocks,
|
2012-10-25 20:14:21 +04:00
|
|
|
int dry_run) {
|
2013-03-05 02:12:17 +04:00
|
|
|
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
|
2012-08-03 04:03:14 +04:00
|
|
|
int pt; /* near block/prev token context index */
|
2013-02-15 22:15:42 +04:00
|
|
|
int c = 0;
|
2012-08-03 04:03:14 +04:00
|
|
|
TOKENEXTRA *t = *tp; /* store tokens starting here */
|
2013-04-04 23:03:27 +04:00
|
|
|
const struct plane_block_idx pb_idx = plane_block_idx(y_blocks, ib);
|
|
|
|
const int eob = xd->plane[pb_idx.plane].eobs[pb_idx.block];
|
2013-04-03 01:50:40 +04:00
|
|
|
const int16_t *qcoeff_ptr = BLOCK_OFFSET(xd->plane[pb_idx.plane].qcoeff,
|
|
|
|
pb_idx.block, 16);
|
2013-03-27 03:46:09 +04:00
|
|
|
int seg_eob, default_eob, pad;
|
2013-03-05 02:12:17 +04:00
|
|
|
const int segment_id = mbmi->segment_id;
|
|
|
|
const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
|
2013-03-27 03:46:09 +04:00
|
|
|
const int *scan, *nb;
|
2012-12-08 04:09:59 +04:00
|
|
|
vp9_coeff_count *counts;
|
|
|
|
vp9_coeff_probs *probs;
|
2013-03-05 02:12:17 +04:00
|
|
|
const int ref = mbmi->ref_frame != INTRA_FRAME;
|
|
|
|
ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
|
2013-03-27 03:46:09 +04:00
|
|
|
uint8_t token_cache[1024];
|
2013-02-20 22:16:24 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
2013-03-27 02:23:30 +04:00
|
|
|
const int nzc_used = get_nzc_used(tx_size);
|
|
|
|
int zerosleft = 0, nzc = 0;
|
2013-02-20 22:16:24 +04:00
|
|
|
if (eob == 0)
|
|
|
|
assert(xd->nzcs[ib] == 0);
|
|
|
|
#endif
|
2013-03-05 02:12:17 +04:00
|
|
|
|
2013-04-04 23:03:27 +04:00
|
|
|
assert((!type && !pb_idx.plane) || (type && pb_idx.plane));
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-12-18 23:25:24 +04:00
|
|
|
|
2012-10-25 20:14:21 +04:00
|
|
|
switch (tx_size) {
|
|
|
|
default:
|
2013-03-06 03:18:06 +04:00
|
|
|
case TX_4X4: {
|
|
|
|
const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
|
|
|
|
get_tx_type_4x4(xd, ib) : DCT_DCT;
|
2013-03-05 02:12:17 +04:00
|
|
|
a_ec = *a;
|
|
|
|
l_ec = *l;
|
2012-10-25 20:14:21 +04:00
|
|
|
seg_eob = 16;
|
2012-12-18 22:49:10 +04:00
|
|
|
scan = vp9_default_zig_zag1d_4x4;
|
2012-10-25 20:14:21 +04:00
|
|
|
if (tx_type != DCT_DCT) {
|
|
|
|
if (tx_type == ADST_DCT) {
|
2012-12-18 22:49:10 +04:00
|
|
|
scan = vp9_row_scan_4x4;
|
2012-10-25 20:14:21 +04:00
|
|
|
} else if (tx_type == DCT_ADST) {
|
2012-12-18 22:49:10 +04:00
|
|
|
scan = vp9_col_scan_4x4;
|
2012-10-25 20:14:21 +04:00
|
|
|
}
|
|
|
|
}
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_4x4;
|
|
|
|
probs = cpi->common.fc.coef_probs_4x4;
|
2012-10-25 20:14:21 +04:00
|
|
|
break;
|
2013-03-06 03:18:06 +04:00
|
|
|
}
|
2013-03-25 23:30:00 +04:00
|
|
|
case TX_8X8: {
|
2013-04-11 03:50:01 +04:00
|
|
|
const int sz = 3 + mb_width_log2(sb_type);
|
|
|
|
const int x = ib & ((1 << sz) - 1), y = ib - x;
|
2013-03-25 23:30:00 +04:00
|
|
|
const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
|
|
|
|
get_tx_type_8x8(xd, y + (x >> 1)) : DCT_DCT;
|
2013-02-15 22:15:42 +04:00
|
|
|
a_ec = (a[0] + a[1]) != 0;
|
|
|
|
l_ec = (l[0] + l[1]) != 0;
|
|
|
|
seg_eob = 64;
|
|
|
|
scan = vp9_default_zig_zag1d_8x8;
|
2013-03-25 23:30:00 +04:00
|
|
|
if (tx_type != DCT_DCT) {
|
|
|
|
if (tx_type == ADST_DCT) {
|
|
|
|
scan = vp9_row_scan_8x8;
|
|
|
|
} else if (tx_type == DCT_ADST) {
|
|
|
|
scan = vp9_col_scan_8x8;
|
|
|
|
}
|
|
|
|
}
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_8x8;
|
|
|
|
probs = cpi->common.fc.coef_probs_8x8;
|
2012-10-25 20:14:21 +04:00
|
|
|
break;
|
2013-03-25 23:30:00 +04:00
|
|
|
}
|
|
|
|
case TX_16X16: {
|
2013-04-11 03:50:01 +04:00
|
|
|
const int sz = 4 + mb_width_log2(sb_type);
|
|
|
|
const int x = ib & ((1 << sz) - 1), y = ib - x;
|
2013-03-25 23:30:00 +04:00
|
|
|
const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
|
|
|
|
get_tx_type_16x16(xd, y + (x >> 2)) : DCT_DCT;
|
2012-12-14 02:58:30 +04:00
|
|
|
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;
|
2012-12-18 23:25:24 +04:00
|
|
|
} else {
|
|
|
|
a_ec = (a[0] + a[1] + a1[0] + a1[1]) != 0;
|
|
|
|
l_ec = (l[0] + l[1] + l1[0] + l1[1]) != 0;
|
2012-12-14 02:58:30 +04:00
|
|
|
}
|
2012-10-25 20:14:21 +04:00
|
|
|
seg_eob = 256;
|
2012-10-31 04:12:12 +04:00
|
|
|
scan = vp9_default_zig_zag1d_16x16;
|
2013-03-25 23:30:00 +04:00
|
|
|
if (tx_type != DCT_DCT) {
|
|
|
|
if (tx_type == ADST_DCT) {
|
|
|
|
scan = vp9_row_scan_16x16;
|
|
|
|
} else if (tx_type == DCT_ADST) {
|
|
|
|
scan = vp9_col_scan_16x16;
|
|
|
|
}
|
|
|
|
}
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_16x16;
|
|
|
|
probs = cpi->common.fc.coef_probs_16x16;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
break;
|
2013-03-25 23:30:00 +04:00
|
|
|
}
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
case TX_32X32:
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
seg_eob = 1024;
|
|
|
|
scan = vp9_default_zig_zag1d_32x32;
|
|
|
|
counts = cpi->coef_counts_32x32;
|
|
|
|
probs = cpi->common.fc.coef_probs_32x32;
|
2012-10-25 20:14:21 +04:00
|
|
|
break;
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
|
|
|
|
2012-12-07 00:40:57 +04:00
|
|
|
VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec);
|
2013-03-27 03:46:09 +04:00
|
|
|
nb = vp9_get_coef_neighbors_handle(scan, &pad);
|
|
|
|
default_eob = seg_eob;
|
2012-12-07 00:40:57 +04:00
|
|
|
|
2013-01-28 19:22:53 +04:00
|
|
|
if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP))
|
|
|
|
seg_eob = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-10-13 22:46:21 +04:00
|
|
|
do {
|
2013-03-25 23:28:24 +04:00
|
|
|
const int band = get_coef_band(scan, tx_size, c);
|
2012-10-13 22:46:21 +04:00
|
|
|
int token;
|
2013-02-20 22:16:24 +04:00
|
|
|
int v = 0;
|
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
2013-03-27 02:23:30 +04:00
|
|
|
if (nzc_used)
|
|
|
|
zerosleft = seg_eob - xd->nzcs[ib] - c + nzc;
|
2013-02-20 22:16:24 +04:00
|
|
|
#endif
|
2012-10-13 22:46:21 +04:00
|
|
|
if (c < eob) {
|
2012-10-25 20:14:21 +04:00
|
|
|
const int rc = scan[c];
|
2013-02-20 22:16:24 +04:00
|
|
|
v = qcoeff_ptr[rc];
|
2012-10-25 20:14:21 +04:00
|
|
|
assert(-DCT_MAX_VALUE <= v && v < DCT_MAX_VALUE);
|
|
|
|
|
2012-10-31 04:12:12 +04:00
|
|
|
t->Extra = vp9_dct_value_tokens_ptr[v].Extra;
|
|
|
|
token = vp9_dct_value_tokens_ptr[v].Token;
|
2012-10-25 20:14:21 +04:00
|
|
|
} else {
|
2013-02-20 22:16:24 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
2013-03-27 02:23:30 +04:00
|
|
|
if (nzc_used)
|
|
|
|
break;
|
|
|
|
else
|
2013-02-20 22:16:24 +04:00
|
|
|
#endif
|
2013-03-27 02:23:30 +04:00
|
|
|
token = DCT_EOB_TOKEN;
|
2012-10-25 20:14:21 +04:00
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
|
|
|
|
t->Token = token;
|
2013-02-20 01:36:38 +04:00
|
|
|
t->context_tree = probs[type][ref][band][pt];
|
2013-02-20 22:16:24 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
// Skip zero node if there are no zeros left
|
2013-03-27 02:23:30 +04:00
|
|
|
if (nzc_used)
|
|
|
|
t->skip_eob_node = 1 + (zerosleft == 0);
|
|
|
|
else
|
2013-02-20 22:16:24 +04:00
|
|
|
#endif
|
2013-03-27 02:23:30 +04:00
|
|
|
t->skip_eob_node = (c > 0) && (token_cache[c - 1] == 0);
|
2013-04-12 00:01:52 +04:00
|
|
|
assert(vp9_coef_encodings[t->Token].len - t->skip_eob_node > 0);
|
2012-09-10 09:42:35 +04:00
|
|
|
if (!dry_run) {
|
2013-02-20 01:36:38 +04:00
|
|
|
++counts[type][ref][band][pt][token];
|
2013-03-27 03:46:09 +04:00
|
|
|
if (!t->skip_eob_node)
|
|
|
|
++cpi->common.fc.eob_branch_counts[tx_size][type][ref][band][pt];
|
2012-09-10 09:42:35 +04:00
|
|
|
}
|
2013-02-20 22:16:24 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
nzc += (v != 0);
|
|
|
|
#endif
|
2013-03-27 03:46:09 +04:00
|
|
|
token_cache[c] = token;
|
2013-02-11 23:19:21 +04:00
|
|
|
|
2013-03-28 20:24:29 +04:00
|
|
|
pt = vp9_get_coef_context(scan, nb, pad, token_cache, c + 1, default_eob);
|
2012-07-24 01:58:07 +04:00
|
|
|
++t;
|
2012-10-13 22:46:21 +04:00
|
|
|
} while (c < eob && ++c < seg_eob);
|
2013-02-20 22:16:24 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
assert(nzc == xd->nzcs[ib]);
|
|
|
|
#endif
|
2012-10-13 22:46:21 +04:00
|
|
|
|
|
|
|
*tp = t;
|
2013-02-15 22:15:42 +04:00
|
|
|
a_ec = l_ec = (c > 0); /* 0 <-> all coeff data is zero */
|
2012-12-07 00:40:57 +04:00
|
|
|
a[0] = a_ec;
|
|
|
|
l[0] = l_ec;
|
|
|
|
|
2013-02-15 22:15:42 +04:00
|
|
|
if (tx_size == TX_8X8) {
|
2012-12-07 00:40:57 +04:00
|
|
|
a[1] = a_ec;
|
|
|
|
l[1] = l_ec;
|
|
|
|
} else if (tx_size == TX_16X16) {
|
2012-12-14 02:58:30 +04:00
|
|
|
if (type != PLANE_TYPE_UV) {
|
|
|
|
a[1] = a[2] = a[3] = a_ec;
|
|
|
|
l[1] = l[2] = l[3] = l_ec;
|
|
|
|
} else {
|
2012-12-18 23:25:24 +04:00
|
|
|
a1[0] = a1[1] = a[1] = a_ec;
|
|
|
|
l1[0] = l1[1] = l[1] = l_ec;
|
2012-12-14 02:58:30 +04:00
|
|
|
}
|
2012-12-18 23:25:24 +04:00
|
|
|
} else if (tx_size == TX_32X32) {
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-12-07 00:40:57 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
struct is_skippable_args {
|
|
|
|
MACROBLOCKD *xd;
|
|
|
|
int *skippable;
|
|
|
|
};
|
|
|
|
static void is_skippable(int plane, int block,
|
|
|
|
int block_size_b, int ss_txfrm_size, void *argv) {
|
|
|
|
struct is_skippable_args *args = argv;
|
|
|
|
args->skippable[0] &= (!args->xd->plane[plane].eobs[block]);
|
2012-09-12 06:36:28 +04:00
|
|
|
}
|
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
int vp9_sb_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
|
2013-04-10 08:28:27 +04:00
|
|
|
const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
|
2013-04-11 22:14:31 +04:00
|
|
|
int result = 1;
|
|
|
|
struct is_skippable_args args = {xd, &result};
|
|
|
|
foreach_transformed_block(xd, bwl + bhl, is_skippable, &args);
|
|
|
|
return result;
|
2013-03-05 02:12:17 +04:00
|
|
|
}
|
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
int vp9_sby_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
|
|
|
|
int result = 1;
|
|
|
|
struct is_skippable_args args = {xd, &result};
|
|
|
|
foreach_transformed_block_in_plane(xd, bwl + bhl, 0, 0, is_skippable, &args);
|
|
|
|
return result;
|
2013-03-05 02:12:17 +04:00
|
|
|
}
|
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
int vp9_sbuv_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
|
|
|
|
int result = 1;
|
|
|
|
struct is_skippable_args args = {xd, &result};
|
|
|
|
foreach_transformed_block_uv(xd, bwl + bhl, is_skippable, &args);
|
|
|
|
return result;
|
2013-03-05 02:12:17 +04:00
|
|
|
}
|
|
|
|
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
void vp9_tokenize_sb(VP9_COMP *cpi,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **t,
|
2013-04-10 08:28:27 +04:00
|
|
|
int dry_run, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
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;
|
2013-01-28 19:22:53 +04:00
|
|
|
const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
|
2013-04-10 08:28:27 +04:00
|
|
|
const TX_SIZE txfm_size = mbmi->txfm_size;
|
|
|
|
const TX_SIZE uv_txfm_size = (bsize < BLOCK_SIZE_SB32X32 &&
|
|
|
|
txfm_size == TX_16X16) ? TX_8X8 :
|
|
|
|
(bsize < BLOCK_SIZE_SB64X64 &&
|
|
|
|
txfm_size == TX_32X32) ? TX_16X16 : txfm_size;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
int b;
|
2013-04-10 08:28:27 +04:00
|
|
|
const int n_y = (1 << (bwl + bhl)), n_uv = (n_y * 3) >> 1;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
mbmi->mb_skip_coeff = vp9_sb_is_skippable(xd, bsize);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
|
|
|
|
if (mbmi->mb_skip_coeff) {
|
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_true_count[mb_skip_context] += skip_inc;
|
2013-04-09 21:54:19 +04:00
|
|
|
vp9_reset_sb_tokens_context(xd, bsize);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_false_count[mb_skip_context] += skip_inc;
|
|
|
|
|
2013-04-10 08:28:27 +04:00
|
|
|
switch (txfm_size) {
|
2013-03-05 02:12:17 +04:00
|
|
|
case TX_32X32:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 64)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_32X32, n_y, dry_run);
|
|
|
|
if (uv_txfm_size == TX_32X32) {
|
|
|
|
assert(bsize == BLOCK_SIZE_SB64X64);
|
|
|
|
tokenize_b(cpi, xd, 256, t, PLANE_TYPE_UV,
|
|
|
|
TX_32X32, n_y, dry_run);
|
|
|
|
tokenize_b(cpi, xd, 320, t, PLANE_TYPE_UV,
|
|
|
|
TX_32X32, n_y, dry_run);
|
|
|
|
} else {
|
|
|
|
for (; b < n_uv; b += 16)
|
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
|
|
|
|
TX_16X16, n_y, dry_run);
|
|
|
|
}
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
case TX_16X16:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 16)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_16X16, n_y, dry_run);
|
|
|
|
if (uv_txfm_size == TX_16X16) {
|
|
|
|
for (; b < n_uv; b += 16)
|
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
|
|
|
|
TX_16X16, n_y, dry_run);
|
|
|
|
} else {
|
|
|
|
for (; b < n_uv; b += 4)
|
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
|
|
|
|
TX_8X8, n_y, dry_run);
|
|
|
|
}
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
case TX_8X8:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 4)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_8X8, n_y, dry_run);
|
|
|
|
for (; b < n_uv; b += 4)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_8X8, n_y, dry_run);
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
case TX_4X4:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b++)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_4X4, n_y, dry_run);
|
|
|
|
for (; b < n_uv; b++)
|
2013-03-05 02:12:17 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
|
2013-04-10 08:28:27 +04:00
|
|
|
TX_4X4, n_y, dry_run);
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
default: assert(0);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
}
|
2013-03-05 02:12:17 +04:00
|
|
|
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
|
|
|
}
|
|
|
|
|
2012-10-31 04:53:32 +04:00
|
|
|
void vp9_tokenize_mb(VP9_COMP *cpi,
|
2012-08-15 14:00:53 +04:00
|
|
|
MACROBLOCKD *xd,
|
2012-08-06 21:51:20 +04:00
|
|
|
TOKENEXTRA **t,
|
|
|
|
int dry_run) {
|
2012-07-14 02:21:29 +04:00
|
|
|
int b;
|
2012-09-10 09:42:35 +04:00
|
|
|
int tx_size = xd->mode_info_context->mbmi.txfm_size;
|
2012-10-29 17:44:18 +04:00
|
|
|
int mb_skip_context = vp9_get_pred_context(&cpi->common, xd, PRED_MBSKIP);
|
2012-08-06 21:51:20 +04:00
|
|
|
TOKENEXTRA *t_backup = *t;
|
2011-11-04 22:29:51 +04:00
|
|
|
|
2012-07-14 02:21:29 +04: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 14:00:53 +04:00
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
2011-10-28 18:27:23 +04:00
|
|
|
|
2013-01-28 19:22:53 +04:00
|
|
|
if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
|
2012-07-14 02:21:29 +04:00
|
|
|
skip_inc = 1;
|
|
|
|
} else
|
|
|
|
skip_inc = 0;
|
2011-10-28 18:27:23 +04:00
|
|
|
|
2013-04-11 22:14:31 +04:00
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = vp9_sb_is_skippable(xd,
|
|
|
|
BLOCK_SIZE_MB16X16);
|
2011-02-15 01:18:18 +03:00
|
|
|
|
2012-08-15 14:00:53 +04:00
|
|
|
if (xd->mode_info_context->mbmi.mb_skip_coeff) {
|
2012-08-06 21:51:20 +04:00
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_true_count[mb_skip_context] += skip_inc;
|
2013-04-09 21:54:19 +04:00
|
|
|
vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
|
2012-12-07 00:40:57 +04:00
|
|
|
|
2012-08-06 21:51:20 +04:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2012-07-14 02:21:29 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-08-06 21:51:20 +04:00
|
|
|
if (!dry_run)
|
|
|
|
cpi->skip_false_count[mb_skip_context] += skip_inc;
|
2011-04-21 22:38:36 +04:00
|
|
|
|
2012-09-10 09:42:35 +04:00
|
|
|
if (tx_size == TX_16X16) {
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, 16, dry_run);
|
2012-08-03 04:03:14 +04:00
|
|
|
for (b = 16; b < 24; b += 4) {
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, 16, dry_run);
|
2012-08-03 04:03:14 +04:00
|
|
|
}
|
2012-10-25 20:14:21 +04:00
|
|
|
} else if (tx_size == TX_8X8) {
|
2012-07-14 02:21:29 +04:00
|
|
|
for (b = 0; b < 16; b += 4) {
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, 16, dry_run);
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-10-22 22:49:00 +04:00
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
|
|
|
|
xd->mode_info_context->mbmi.mode == SPLITMV) {
|
2012-10-25 20:14:21 +04:00
|
|
|
for (b = 16; b < 24; b++) {
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, 16, dry_run);
|
2012-10-25 20:14:21 +04:00
|
|
|
}
|
2012-10-05 16:08:20 +04:00
|
|
|
} else {
|
2012-09-12 06:36:28 +04:00
|
|
|
for (b = 16; b < 24; b += 4) {
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, 16, dry_run);
|
2012-09-12 06:36:28 +04:00
|
|
|
}
|
2011-02-15 01:18:18 +03:00
|
|
|
}
|
2012-06-25 23:26:09 +04:00
|
|
|
} else {
|
2013-02-15 22:15:42 +04:00
|
|
|
for (b = 0; b < 16; b++)
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, 16, dry_run);
|
2013-02-15 22:15:42 +04:00
|
|
|
for (b = 16; b < 24; b++)
|
2013-04-04 23:03:27 +04:00
|
|
|
tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, 16, dry_run);
|
2012-06-25 23:26:09 +04:00
|
|
|
}
|
2012-08-06 21:51:20 +04:00
|
|
|
if (dry_run)
|
|
|
|
*t = t_backup;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2010-08-31 18:49:57 +04:00
|
|
|
|
2010-05-18 19:58:33 +04:00
|
|
|
#ifdef ENTROPY_STATS
|
2012-07-14 02:21:29 +04:00
|
|
|
void init_context_counters(void) {
|
|
|
|
FILE *f = fopen("context.bin", "rb");
|
|
|
|
if (!f) {
|
2012-12-08 04:09:59 +04:00
|
|
|
vpx_memset(context_counters_4x4, 0, sizeof(context_counters_4x4));
|
2012-07-14 02:21:29 +04:00
|
|
|
vpx_memset(context_counters_8x8, 0, sizeof(context_counters_8x8));
|
2012-08-03 04:03:14 +04:00
|
|
|
vpx_memset(context_counters_16x16, 0, sizeof(context_counters_16x16));
|
2012-12-08 04:09:59 +04:00
|
|
|
vpx_memset(context_counters_32x32, 0, sizeof(context_counters_32x32));
|
2012-07-14 02:21:29 +04:00
|
|
|
} else {
|
2012-12-08 04:09:59 +04:00
|
|
|
fread(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fread(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
|
2012-08-03 04:03:14 +04:00
|
|
|
fread(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
|
2012-12-08 04:09:59 +04:00
|
|
|
fread(context_counters_32x32, sizeof(context_counters_32x32), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
f = fopen("treeupdate.bin", "rb");
|
|
|
|
if (!f) {
|
2012-12-08 04:09:59 +04:00
|
|
|
vpx_memset(tree_update_hist_4x4, 0, sizeof(tree_update_hist_4x4));
|
2012-07-14 02:21:29 +04:00
|
|
|
vpx_memset(tree_update_hist_8x8, 0, sizeof(tree_update_hist_8x8));
|
2012-08-03 04:03:14 +04:00
|
|
|
vpx_memset(tree_update_hist_16x16, 0, sizeof(tree_update_hist_16x16));
|
2012-12-08 04:09:59 +04:00
|
|
|
vpx_memset(tree_update_hist_32x32, 0, sizeof(tree_update_hist_32x32));
|
2012-07-14 02:21:29 +04:00
|
|
|
} else {
|
2012-12-08 04:09:59 +04:00
|
|
|
fread(tree_update_hist_4x4, sizeof(tree_update_hist_4x4), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fread(tree_update_hist_8x8, sizeof(tree_update_hist_8x8), 1, f);
|
2012-08-03 04:03:14 +04:00
|
|
|
fread(tree_update_hist_16x16, sizeof(tree_update_hist_16x16), 1, f);
|
2012-12-08 04:09:59 +04:00
|
|
|
fread(tree_update_hist_32x32, sizeof(tree_update_hist_32x32), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fclose(f);
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
static void print_counter(FILE *f, vp9_coeff_accum *context_counters,
|
|
|
|
int block_types, const char *header) {
|
2013-02-20 01:36:38 +04:00
|
|
|
int type, ref, band, pt, t;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
fprintf(f, "static const vp9_coeff_count %s = {\n", header);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-12-12 22:25:58 +04:00
|
|
|
#define Comma(X) (X ? "," : "")
|
2012-07-14 02:21:29 +04:00
|
|
|
type = 0;
|
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
ref = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "%s\n { /* block Type %d */", Comma(type), type);
|
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
fprintf(f, "%s\n { /* %s */", Comma(type), ref ? "Inter" : "Intra");
|
|
|
|
band = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
fprintf(f, "%s\n { /* Coeff Band %d */", Comma(band), band);
|
|
|
|
pt = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
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);
|
2013-03-27 03:46:09 +04:00
|
|
|
} while (++t < 1 + MAX_ENTROPY_TOKENS);
|
2013-02-20 01:36:38 +04:00
|
|
|
fprintf(f, "}");
|
|
|
|
} while (++pt < PREV_COEF_CONTEXTS);
|
|
|
|
fprintf(f, "\n }");
|
|
|
|
} while (++band < COEF_BANDS);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "\n }");
|
2013-02-20 01:36:38 +04:00
|
|
|
} while (++ref < REF_TYPES);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "\n }");
|
2012-12-08 04:09:59 +04:00
|
|
|
} while (++type < block_types);
|
2012-08-03 04:03:14 +04:00
|
|
|
fprintf(f, "\n};\n");
|
2012-12-08 04:09:59 +04:00
|
|
|
}
|
2012-03-22 02:22:21 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
static void print_probs(FILE *f, vp9_coeff_accum *context_counters,
|
|
|
|
int block_types, const char *header) {
|
2013-02-20 01:36:38 +04:00
|
|
|
int type, ref, band, pt, t;
|
2012-08-03 04:03:14 +04:00
|
|
|
|
2012-12-12 22:25:58 +04:00
|
|
|
fprintf(f, "static const vp9_coeff_probs %s = {", header);
|
2012-03-22 02:22:21 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
type = 0;
|
2012-12-12 22:25:58 +04:00
|
|
|
#define Newline(x, spaces) (x ? " " : "\n" spaces)
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2012-12-12 22:25:58 +04:00
|
|
|
fprintf(f, "%s%s{ /* block Type %d */",
|
|
|
|
Comma(type), Newline(type, " "), type);
|
2013-02-20 01:36:38 +04:00
|
|
|
ref = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
fprintf(f, "%s%s{ /* %s */",
|
|
|
|
Comma(band), Newline(band, " "), ref ? "Inter" : "Intra");
|
|
|
|
band = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
fprintf(f, "%s%s{ /* Coeff Band %d */",
|
|
|
|
Comma(band), Newline(band, " "), band);
|
|
|
|
pt = 0;
|
2012-07-14 02:21:29 +04:00
|
|
|
do {
|
2013-02-20 01:36:38 +04:00
|
|
|
unsigned int branch_ct[ENTROPY_NODES][2];
|
2013-03-27 03:46:09 +04:00
|
|
|
unsigned int coef_counts[MAX_ENTROPY_TOKENS + 1];
|
2013-02-20 01:36:38 +04:00
|
|
|
vp9_prob coef_probs[ENTROPY_NODES];
|
|
|
|
|
2013-03-27 03:46:09 +04:00
|
|
|
if (pt >= 3 && band == 0)
|
|
|
|
break;
|
|
|
|
for (t = 0; t < MAX_ENTROPY_TOKENS + 1; ++t)
|
2013-02-20 01:36:38 +04:00
|
|
|
coef_counts[t] = context_counters[type][ref][band][pt][t];
|
2013-03-19 01:39:36 +04:00
|
|
|
vp9_tree_probs_from_distribution(vp9_coef_tree, coef_probs,
|
|
|
|
branch_ct, coef_counts, 0);
|
2013-03-27 03:46:09 +04:00
|
|
|
branch_ct[0][1] = coef_counts[MAX_ENTROPY_TOKENS] - branch_ct[0][0];
|
|
|
|
coef_probs[0] = get_binary_prob(branch_ct[0][0], branch_ct[0][1]);
|
2013-02-20 01:36:38 +04:00
|
|
|
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);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "\n }");
|
2013-02-20 01:36:38 +04:00
|
|
|
} while (++ref < REF_TYPES);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "\n }");
|
2012-12-08 04:09:59 +04:00
|
|
|
} while (++type < block_types);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(f, "\n};\n");
|
2012-12-08 04:09:59 +04:00
|
|
|
}
|
2012-03-22 02:22:21 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
void print_context_counters() {
|
|
|
|
FILE *f = fopen("vp9_context.c", "w");
|
2012-03-22 02:22:21 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
fprintf(f, "#include \"vp9_entropy.h\"\n");
|
|
|
|
fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n");
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
/* print counts */
|
2013-02-20 01:36:38 +04:00
|
|
|
print_counter(f, context_counters_4x4, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"vp9_default_coef_counts_4x4[BLOCK_TYPES]");
|
2013-02-20 01:36:38 +04:00
|
|
|
print_counter(f, context_counters_8x8, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"vp9_default_coef_counts_8x8[BLOCK_TYPES]");
|
2013-02-20 01:36:38 +04:00
|
|
|
print_counter(f, context_counters_16x16, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"vp9_default_coef_counts_16x16[BLOCK_TYPES]");
|
|
|
|
print_counter(f, context_counters_32x32, BLOCK_TYPES,
|
|
|
|
"vp9_default_coef_counts_32x32[BLOCK_TYPES]");
|
2012-08-03 04:03:14 +04:00
|
|
|
|
2012-12-08 04:09:59 +04:00
|
|
|
/* print coefficient probabilities */
|
2013-02-20 01:36:38 +04:00
|
|
|
print_probs(f, context_counters_4x4, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"default_coef_probs_4x4[BLOCK_TYPES]");
|
2013-02-20 01:36:38 +04:00
|
|
|
print_probs(f, context_counters_8x8, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"default_coef_probs_8x8[BLOCK_TYPES]");
|
2013-02-20 01:36:38 +04:00
|
|
|
print_probs(f, context_counters_16x16, BLOCK_TYPES,
|
2013-03-05 02:12:17 +04:00
|
|
|
"default_coef_probs_16x16[BLOCK_TYPES]");
|
|
|
|
print_probs(f, context_counters_32x32, BLOCK_TYPES,
|
|
|
|
"default_coef_probs_32x32[BLOCK_TYPES]");
|
2012-08-03 04:03:14 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
f = fopen("context.bin", "wb");
|
2012-12-08 04:09:59 +04:00
|
|
|
fwrite(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fwrite(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
|
2012-08-03 04:03:14 +04:00
|
|
|
fwrite(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
|
2012-12-08 04:09:59 +04:00
|
|
|
fwrite(context_counters_32x32, sizeof(context_counters_32x32), 1, f);
|
2012-07-14 02:21:29 +04:00
|
|
|
fclose(f);
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-10-30 23:58:42 +04:00
|
|
|
void vp9_tokenize_initialize() {
|
2012-07-14 02:21:29 +04:00
|
|
|
fill_value_tokens();
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2013-03-05 02:12:17 +04:00
|
|
|
static void stuff_b(VP9_COMP *cpi,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
const int ib,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
PLANE_TYPE type,
|
|
|
|
TX_SIZE tx_size,
|
|
|
|
int dry_run) {
|
2013-02-20 22:16:24 +04:00
|
|
|
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
|
|
|
|
const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
|
2012-12-08 04:09:59 +04:00
|
|
|
vp9_coeff_count *counts;
|
|
|
|
vp9_coeff_probs *probs;
|
2012-10-25 03:59:00 +04:00
|
|
|
int pt, band;
|
|
|
|
TOKENEXTRA *t = *tp;
|
2013-03-05 02:12:17 +04:00
|
|
|
const int ref = mbmi->ref_frame != INTRA_FRAME;
|
|
|
|
ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
|
2013-03-27 02:23:30 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
const int nzc_used = get_nzc_used(tx_size);
|
|
|
|
#endif
|
2013-03-05 02:12:17 +04:00
|
|
|
|
2013-04-11 03:50:01 +04:00
|
|
|
if (sb_type == BLOCK_SIZE_SB64X64) {
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-10-25 03:59:00 +04:00
|
|
|
switch (tx_size) {
|
|
|
|
default:
|
|
|
|
case TX_4X4:
|
2013-03-05 02:12:17 +04:00
|
|
|
a_ec = a[0];
|
|
|
|
l_ec = l[0];
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_4x4;
|
|
|
|
probs = cpi->common.fc.coef_probs_4x4;
|
2012-10-25 03:59:00 +04:00
|
|
|
break;
|
|
|
|
case TX_8X8:
|
2013-02-15 22:15:42 +04:00
|
|
|
a_ec = (a[0] + a[1]) != 0;
|
|
|
|
l_ec = (l[0] + l[1]) != 0;
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_8x8;
|
|
|
|
probs = cpi->common.fc.coef_probs_8x8;
|
2012-10-25 03:59:00 +04:00
|
|
|
break;
|
|
|
|
case TX_16X16:
|
2012-12-14 02:58:30 +04:00
|
|
|
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;
|
2012-12-18 23:25:24 +04:00
|
|
|
} else {
|
|
|
|
a_ec = (a[0] + a[1] + a1[0] + a1[1]) != 0;
|
|
|
|
l_ec = (l[0] + l[1] + l1[0] + l1[1]) != 0;
|
2012-12-14 02:58:30 +04:00
|
|
|
}
|
2013-02-20 01:36:38 +04:00
|
|
|
counts = cpi->coef_counts_16x16;
|
|
|
|
probs = cpi->common.fc.coef_probs_16x16;
|
2012-10-25 03:59:00 +04:00
|
|
|
break;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
case TX_32X32:
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
counts = cpi->coef_counts_32x32;
|
|
|
|
probs = cpi->common.fc.coef_probs_32x32;
|
|
|
|
break;
|
2012-10-25 03:59:00 +04:00
|
|
|
}
|
2012-12-07 00:40:57 +04:00
|
|
|
|
2013-03-27 02:23:30 +04:00
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
|
|
|
if (!nzc_used) {
|
|
|
|
#endif
|
|
|
|
VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec);
|
|
|
|
band = 0;
|
|
|
|
t->Token = DCT_EOB_TOKEN;
|
|
|
|
t->context_tree = probs[type][ref][band][pt];
|
|
|
|
t->skip_eob_node = 0;
|
|
|
|
++t;
|
|
|
|
*tp = t;
|
|
|
|
if (!dry_run) {
|
|
|
|
++counts[type][ref][band][pt][DCT_EOB_TOKEN];
|
|
|
|
}
|
|
|
|
#if CONFIG_CODE_NONZEROCOUNT
|
2013-02-20 22:16:24 +04:00
|
|
|
}
|
|
|
|
#endif
|
2013-03-27 02:23:30 +04:00
|
|
|
*a = *l = 0;
|
2013-02-15 22:15:42 +04:00
|
|
|
if (tx_size == TX_8X8) {
|
2012-12-07 00:40:57 +04:00
|
|
|
a[1] = 0;
|
|
|
|
l[1] = 0;
|
|
|
|
} else if (tx_size == TX_16X16) {
|
2012-12-14 02:58:30 +04:00
|
|
|
if (type != PLANE_TYPE_UV) {
|
|
|
|
a[1] = a[2] = a[3] = 0;
|
|
|
|
l[1] = l[2] = l[3] = 0;
|
|
|
|
} else {
|
2012-12-18 23:25:24 +04:00
|
|
|
a1[0] = a1[1] = a[1] = a_ec;
|
|
|
|
l1[0] = l1[1] = l[1] = l_ec;
|
2012-12-14 02:58:30 +04:00
|
|
|
}
|
2012-12-18 23:25:24 +04:00
|
|
|
} else if (tx_size == TX_32X32) {
|
2013-03-05 02:12:17 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-12-07 00:40:57 +04:00
|
|
|
}
|
2011-02-15 01:18:18 +03:00
|
|
|
}
|
|
|
|
|
2012-11-01 01:40:53 +04:00
|
|
|
static void stuff_mb_8x8(VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **t, int dry_run) {
|
2012-07-14 02:21:29 +04:00
|
|
|
int b;
|
|
|
|
|
2013-02-15 22:15:42 +04:00
|
|
|
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);
|
2012-08-03 04:03:14 +04:00
|
|
|
}
|
|
|
|
|
2012-11-01 01:40:53 +04:00
|
|
|
static void stuff_mb_16x16(VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **t, int dry_run) {
|
2012-10-25 03:59:00 +04:00
|
|
|
int b;
|
2012-12-07 00:40:57 +04:00
|
|
|
stuff_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
|
2012-08-03 04:03:14 +04:00
|
|
|
|
|
|
|
for (b = 16; b < 24; b += 4) {
|
2012-12-07 00:40:57 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2012-11-01 01:40:53 +04:00
|
|
|
static void stuff_mb_4x4(VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **t, int dry_run) {
|
2012-07-14 02:21:29 +04:00
|
|
|
int b;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-02-15 22:15:42 +04:00
|
|
|
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);
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-09-12 06:36:28 +04:00
|
|
|
|
2012-11-01 01:40:53 +04:00
|
|
|
static void stuff_mb_8x8_4x4uv(VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **t, int dry_run) {
|
2012-09-12 06:36:28 +04:00
|
|
|
int b;
|
|
|
|
|
2013-02-15 22:15:42 +04:00
|
|
|
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++)
|
2012-12-07 00:40:57 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
|
2012-09-12 06:36:28 +04:00
|
|
|
}
|
|
|
|
|
2012-10-31 04:53:32 +04:00
|
|
|
void vp9_stuff_mb(VP9_COMP *cpi, MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run) {
|
2012-10-15 21:52:13 +04:00
|
|
|
TX_SIZE tx_size = xd->mode_info_context->mbmi.txfm_size;
|
2012-10-25 03:59:00 +04:00
|
|
|
TOKENEXTRA * const t_backup = *t;
|
2012-10-15 21:52:13 +04:00
|
|
|
|
|
|
|
if (tx_size == TX_16X16) {
|
2012-11-01 01:40:53 +04:00
|
|
|
stuff_mb_16x16(cpi, xd, t, dry_run);
|
2012-10-15 21:52:13 +04:00
|
|
|
} else if (tx_size == TX_8X8) {
|
2012-10-22 22:49:00 +04:00
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
|
|
|
|
xd->mode_info_context->mbmi.mode == SPLITMV) {
|
2012-11-01 01:40:53 +04:00
|
|
|
stuff_mb_8x8_4x4uv(cpi, xd, t, dry_run);
|
2012-10-15 21:52:13 +04:00
|
|
|
} else {
|
2012-11-01 01:40:53 +04:00
|
|
|
stuff_mb_8x8(cpi, xd, t, dry_run);
|
2012-10-15 21:52:13 +04:00
|
|
|
}
|
|
|
|
} else {
|
2012-11-01 01:40:53 +04:00
|
|
|
stuff_mb_4x4(cpi, xd, t, dry_run);
|
2012-10-15 21:52:13 +04:00
|
|
|
}
|
2012-10-25 03:59:00 +04:00
|
|
|
|
|
|
|
if (dry_run) {
|
|
|
|
*t = t_backup;
|
|
|
|
}
|
2012-10-15 21:52:13 +04:00
|
|
|
}
|
|
|
|
|
2013-04-10 08:28:27 +04:00
|
|
|
void vp9_stuff_sb(VP9_COMP *cpi, MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
|
|
|
|
const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
|
|
|
|
const TX_SIZE txfm_size = mbmi->txfm_size;
|
|
|
|
const TX_SIZE uv_txfm_size = (bsize < BLOCK_SIZE_SB32X32 &&
|
|
|
|
txfm_size == TX_16X16) ? TX_8X8 :
|
|
|
|
(bsize < BLOCK_SIZE_SB64X64 &&
|
|
|
|
txfm_size == TX_32X32) ? TX_16X16 : txfm_size;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
int b;
|
2013-04-10 08:28:27 +04:00
|
|
|
const int n_y = (1 << (bwl + bhl)), n_uv = (n_y * 3) >> 1;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
TOKENEXTRA * const t_backup = *t;
|
|
|
|
|
2013-04-10 08:28:27 +04:00
|
|
|
switch (txfm_size) {
|
2013-03-05 02:12:17 +04:00
|
|
|
case TX_32X32:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 64)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_32X32, dry_run);
|
2013-04-10 08:28:27 +04:00
|
|
|
if (uv_txfm_size == TX_32X32) {
|
|
|
|
assert(bsize == BLOCK_SIZE_SB64X64);
|
|
|
|
stuff_b(cpi, xd, 256, t, PLANE_TYPE_UV, TX_32X32, dry_run);
|
|
|
|
stuff_b(cpi, xd, 320, t, PLANE_TYPE_UV, TX_32X32, dry_run);
|
|
|
|
} else {
|
|
|
|
for (; b < n_uv; b += 16)
|
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run);
|
|
|
|
}
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
case TX_16X16:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 16)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
|
2013-04-10 08:28:27 +04:00
|
|
|
if (uv_txfm_size == TX_16X16) {
|
|
|
|
for (; b < n_uv; b += 16)
|
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_16X16, dry_run);
|
|
|
|
} else {
|
|
|
|
for (; b < n_uv; b += 4)
|
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
|
|
|
|
}
|
2013-03-05 02:12:17 +04:00
|
|
|
break;
|
|
|
|
case TX_8X8:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b += 4)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
|
2013-04-10 08:28:27 +04:00
|
|
|
for (; b < n_uv; b += 4)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
|
|
|
|
break;
|
|
|
|
case TX_4X4:
|
2013-04-10 08:28:27 +04:00
|
|
|
for (b = 0; b < n_y; b++)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
|
2013-04-10 08:28:27 +04:00
|
|
|
for (; b < n_uv; b++)
|
2013-03-05 02:12:17 +04:00
|
|
|
stuff_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
|
|
|
|
break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-08 02:45:05 +04:00
|
|
|
|
|
|
|
if (dry_run) {
|
|
|
|
*t = t_backup;
|
|
|
|
}
|
|
|
|
}
|