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-09 17:29:20 +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-09 17:29:20 +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 "onyxd_int.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/header.h"
|
|
|
|
#include "vp8/common/reconintra.h"
|
|
|
|
#include "vp8/common/reconintra4x4.h"
|
|
|
|
#include "vp8/common/recon.h"
|
|
|
|
#include "vp8/common/reconinter.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "dequantize.h"
|
|
|
|
#include "detokenize.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/invtrans.h"
|
|
|
|
#include "vp8/common/alloccommon.h"
|
|
|
|
#include "vp8/common/entropymode.h"
|
|
|
|
#include "vp8/common/quant_common.h"
|
2010-09-16 20:08:52 +02:00
|
|
|
#include "vpx_scale/vpxscale.h"
|
|
|
|
#include "vpx_scale/yv12extend.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/setupintrarecon.h"
|
2010-09-09 20:42:48 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "decodemv.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/extend.h"
|
2011-12-06 21:03:42 +01:00
|
|
|
#include "vp8/common/modecont.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/idct.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "dequantize.h"
|
|
|
|
#include "dboolhuff.h"
|
|
|
|
|
2011-10-05 12:26:00 +02:00
|
|
|
#include "vp8/common/seg_common.h"
|
2012-04-12 18:24:03 +02:00
|
|
|
#include "vp8/common/entropy.h"
|
2011-10-05 12:26:00 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#include <assert.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2011-12-01 01:25:00 +01:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef DEC_DEBUG
|
|
|
|
int dec_debug = 0;
|
|
|
|
#endif
|
|
|
|
|
2012-06-06 00:25:07 +02:00
|
|
|
#define COEFCOUNT_TESTING
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static int merge_index(int v, int n, int modulus) {
|
|
|
|
int max1 = (n - 1 - modulus / 2) / modulus + 1;
|
|
|
|
if (v < max1) v = v * modulus + modulus / 2;
|
|
|
|
else {
|
|
|
|
int w;
|
|
|
|
v -= max1;
|
|
|
|
w = v;
|
|
|
|
v += (v + modulus - modulus / 2) / modulus;
|
|
|
|
while (v % modulus == modulus / 2 ||
|
|
|
|
w != v - (v + modulus - modulus / 2) / modulus) v++;
|
|
|
|
}
|
|
|
|
return v;
|
2012-05-03 11:22:26 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static int inv_remap_prob(int v, int m) {
|
|
|
|
const int n = 256;
|
|
|
|
const int modulus = MODULUS_PARAM;
|
2012-08-07 00:05:24 +02:00
|
|
|
int i;
|
2012-07-14 00:21:29 +02:00
|
|
|
v = merge_index(v, n - 1, modulus);
|
|
|
|
if ((m << 1) <= n) {
|
|
|
|
i = inv_recenter_nonneg(v + 1, m);
|
|
|
|
} else {
|
|
|
|
i = n - 1 - inv_recenter_nonneg(v + 1, n - 1 - m);
|
|
|
|
}
|
|
|
|
return i;
|
2012-04-12 18:24:03 +02:00
|
|
|
}
|
2012-05-03 11:22:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static vp8_prob read_prob_diff_update(vp8_reader *const bc, int oldp) {
|
|
|
|
int delp = vp8_decode_term_subexp(bc, SUBEXP_PARAM, 255);
|
|
|
|
return (vp8_prob)inv_remap_prob(delp, oldp);
|
2012-05-03 11:22:26 +02:00
|
|
|
}
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8cx_init_de_quantizer(VP8D_COMP *pbi) {
|
|
|
|
int i;
|
|
|
|
int Q;
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
|
|
|
|
for (Q = 0; Q < QINDEX_RANGE; Q++) {
|
|
|
|
pc->Y1dequant[Q][0] = (short)vp8_dc_quant(Q, pc->y1dc_delta_q);
|
|
|
|
pc->Y2dequant[Q][0] = (short)vp8_dc2quant(Q, pc->y2dc_delta_q);
|
|
|
|
pc->UVdequant[Q][0] = (short)vp8_dc_uv_quant(Q, pc->uvdc_delta_q);
|
|
|
|
|
|
|
|
/* all the ac values =; */
|
|
|
|
for (i = 1; i < 16; i++) {
|
|
|
|
int rc = vp8_default_zig_zag1d[i];
|
|
|
|
|
|
|
|
pc->Y1dequant[Q][rc] = (short)vp8_ac_yquant(Q);
|
|
|
|
pc->Y2dequant[Q][rc] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
|
|
|
|
pc->UVdequant[Q][rc] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd) {
|
|
|
|
int i;
|
|
|
|
int QIndex;
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
|
|
|
|
// Set the Q baseline allowing for any segment level adjustment
|
|
|
|
if (segfeature_active(xd, segment_id, SEG_LVL_ALT_Q)) {
|
|
|
|
/* Abs Value */
|
|
|
|
if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
|
|
|
|
QIndex = get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
|
|
|
|
|
|
|
|
/* Delta Value */
|
|
|
|
else {
|
|
|
|
QIndex = pc->base_qindex +
|
|
|
|
get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
|
|
|
|
QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0; /* Clamp to valid range */
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else
|
|
|
|
QIndex = pc->base_qindex;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Set up the block level dequant pointers */
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
xd->block[i].dequant = pc->Y1dequant[QIndex];
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-06-25 21:26:09 +02:00
|
|
|
xd->q_index = QIndex;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#if CONFIG_LOSSLESS
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!QIndex) {
|
|
|
|
pbi->common.rtcd.idct.idct1 = vp8_short_inv_walsh4x4_1_x8_c;
|
|
|
|
pbi->common.rtcd.idct.idct16 = vp8_short_inv_walsh4x4_x8_c;
|
|
|
|
pbi->common.rtcd.idct.idct1_scalar_add = vp8_dc_only_inv_walsh_add_c;
|
|
|
|
pbi->common.rtcd.idct.iwalsh1 = vp8_short_inv_walsh4x4_1_lossless_c;
|
|
|
|
pbi->common.rtcd.idct.iwalsh16 = vp8_short_inv_walsh4x4_lossless_c;
|
|
|
|
pbi->dequant.idct_add = vp8_dequant_idct_add_lossless_c;
|
|
|
|
pbi->dequant.dc_idct_add = vp8_dequant_dc_idct_add_lossless_c;
|
|
|
|
pbi->dequant.dc_idct_add_y_block = vp8_dequant_dc_idct_add_y_block_lossless_c;
|
|
|
|
pbi->dequant.idct_add_y_block = vp8_dequant_idct_add_y_block_lossless_c;
|
|
|
|
pbi->dequant.idct_add_uv_block = vp8_dequant_idct_add_uv_block_lossless_c;
|
|
|
|
} else {
|
|
|
|
pbi->common.rtcd.idct.idct1 = vp8_short_idct4x4llm_1_c;
|
|
|
|
pbi->common.rtcd.idct.idct16 = vp8_short_idct4x4llm_c;
|
|
|
|
pbi->common.rtcd.idct.idct1_scalar_add = vp8_dc_only_idct_add_c;
|
|
|
|
pbi->common.rtcd.idct.iwalsh1 = vp8_short_inv_walsh4x4_1_c;
|
|
|
|
pbi->common.rtcd.idct.iwalsh16 = vp8_short_inv_walsh4x4_c;
|
|
|
|
pbi->dequant.idct_add = vp8_dequant_idct_add_c;
|
|
|
|
pbi->dequant.dc_idct_add = vp8_dequant_dc_idct_add_c;
|
|
|
|
pbi->dequant.dc_idct_add_y_block = vp8_dequant_dc_idct_add_y_block_c;
|
|
|
|
pbi->dequant.idct_add_y_block = vp8_dequant_idct_add_y_block_c;
|
|
|
|
pbi->dequant.idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
|
|
|
|
}
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 16; i < 24; i++) {
|
|
|
|
xd->block[i].dequant = pc->UVdequant[QIndex];
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->block[24].dequant = pc->Y2dequant[QIndex];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_RUNTIME_CPU_DETECT
|
|
|
|
#define RTCD_VTABLE(x) (&(pbi)->common.rtcd.x)
|
|
|
|
#else
|
|
|
|
#define RTCD_VTABLE(x) NULL
|
|
|
|
#endif
|
|
|
|
|
2010-10-28 01:04:02 +02:00
|
|
|
/* skip_recon_mb() is Modified: Instead of writing the result to predictor buffer and then copying it
|
|
|
|
* to dst buffer, we can write the result directly to dst buffer. This eliminates unnecessary copy.
|
|
|
|
*/
|
2012-07-14 00:21:29 +02:00
|
|
|
static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd) {
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sbuv_s)(xd);
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon,
|
|
|
|
build_intra_predictors_sby_s)(xd);
|
|
|
|
} else {
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv_s)(xd);
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon,
|
|
|
|
build_intra_predictors_mby_s)(xd);
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
vp8_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride, xd->dst.uv_stride);
|
|
|
|
} else {
|
|
|
|
#endif
|
2012-08-09 02:12:12 +02:00
|
|
|
vp8_build_1st_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride, xd->dst.uv_stride);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame) {
|
|
|
|
vp8_build_2nd_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride, xd->dst.uv_stride);
|
2011-12-01 01:25:00 +01:00
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef DEC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (dec_debug) {
|
|
|
|
int i, j;
|
|
|
|
printf("Generating predictors\n");
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
for (j = 0; j < 16; j++) printf("%3d ", xd->dst.y_buffer[i * xd->dst.y_stride + j]);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
#endif
|
2011-12-01 01:25:00 +01:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2011-12-07 22:03:57 +01:00
|
|
|
extern const int vp8_i8x8_block[4];
|
2011-05-02 15:30:51 +02:00
|
|
|
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
|
2012-08-20 23:43:34 +02:00
|
|
|
unsigned int mb_col) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int eobtotal = 0;
|
|
|
|
MB_PREDICTION_MODE mode;
|
|
|
|
int i;
|
|
|
|
int tx_type;
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
VP8_COMMON *pc = &pbi->common;
|
|
|
|
int orig_skip_flag = xd->mode_info_context->mbmi.mb_skip_coeff;
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-16 22:25:49 +02:00
|
|
|
int QIndex;
|
|
|
|
int active_ht;
|
2012-06-25 21:26:09 +02:00
|
|
|
#endif
|
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM16X16
|
|
|
|
int active_ht16;
|
|
|
|
#endif
|
|
|
|
|
2012-08-16 22:25:49 +02:00
|
|
|
// re-initialize macroblock dequantizer before detokenization
|
|
|
|
if (xd->segmentation_enabled)
|
|
|
|
mb_init_dequantizer(pbi, xd);
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pbi->common.frame_type == KEY_FRAME) {
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode <= TM_PRED ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEWMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == ZEROMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEARMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEARESTMV)
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_16X16;
|
|
|
|
else if (pbi->common.txfm_mode == ALLOW_8X8 &&
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context->mbmi.mode != I8X8_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != B_PRED)
|
2012-08-03 02:03:14 +02:00
|
|
|
#else
|
|
|
|
if (pbi->common.txfm_mode == ALLOW_8X8 &&
|
|
|
|
xd->mode_info_context->mbmi.mode != I8X8_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != B_PRED)
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
|
2012-03-19 19:03:27 +01:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
|
|
|
|
} else {
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode <= TM_PRED ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEWMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == ZEROMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEARMV ||
|
|
|
|
xd->mode_info_context->mbmi.mode == NEARESTMV) {
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_16X16;
|
|
|
|
} else if (pbi->common.txfm_mode == ALLOW_8X8 &&
|
|
|
|
xd->mode_info_context->mbmi.mode != I8X8_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != B_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != SPLITMV) {
|
|
|
|
#else
|
|
|
|
if (pbi->common.txfm_mode == ALLOW_8X8 &&
|
|
|
|
xd->mode_info_context->mbmi.mode != I8X8_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != B_PRED &&
|
|
|
|
xd->mode_info_context->mbmi.mode != SPLITMV) {
|
|
|
|
#endif
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
|
|
|
|
}
|
|
|
|
else {
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
|
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
|
|
|
}
|
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
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED) {
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
|
|
|
|
}
|
|
|
|
#endif
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_8X8;
|
|
|
|
}
|
|
|
|
#endif
|
2012-08-01 19:18:25 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
tx_type = xd->mode_info_context->mbmi.txfm_size;
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.mb_skip_coeff) {
|
|
|
|
vp8_reset_mb_tokens_context(xd);
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
xd->above_context++;
|
|
|
|
xd->left_context++;
|
|
|
|
vp8_reset_mb_tokens_context(xd);
|
|
|
|
xd->above_context--;
|
|
|
|
xd->left_context--;
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (!vp8dx_bool_error(xd->current_bc)) {
|
|
|
|
for (i = 0; i < 25; i++) {
|
|
|
|
xd->block[i].eob = 0;
|
|
|
|
xd->eobs[i] = 0;
|
2010-05-28 20:28:12 +02:00
|
|
|
}
|
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)
|
|
|
|
eobtotal = vp8_decode_mb_tokens_16x16(pbi, xd);
|
|
|
|
else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (tx_type == TX_8X8)
|
|
|
|
eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd);
|
|
|
|
else
|
|
|
|
eobtotal = vp8_decode_mb_tokens(pbi, xd);
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef DEC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (dec_debug) {
|
|
|
|
printf("\nTokens (%d)\n", eobtotal);
|
|
|
|
for (i = 0; i < 400; i++) {
|
|
|
|
printf("%3d ", xd->qcoeff[i]);
|
|
|
|
if (i % 16 == 15) printf("\n");
|
|
|
|
}
|
|
|
|
printf("\n");
|
2010-05-28 20:28:12 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
#endif
|
|
|
|
}
|
2010-05-28 20:28:12 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
mode = xd->mode_info_context->mbmi.mode;
|
2012-07-18 22:43:01 +02:00
|
|
|
#if CONFIG_SWITCHABLE_INTERP
|
|
|
|
if (pbi->common.frame_type != KEY_FRAME)
|
|
|
|
vp8_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
|
|
|
|
&pbi->common);
|
|
|
|
#endif
|
2011-06-28 16:22:13 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV
|
|
|
|
&& mode != I8X8_PRED
|
|
|
|
&& !vp8dx_bool_error(xd->current_bc)
|
|
|
|
) {
|
|
|
|
/* Special case: Force the loopfilter to skip when eobtotal and
|
|
|
|
* mb_skip_coeff are zero.
|
|
|
|
* */
|
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = 1;
|
2011-04-26 15:37:19 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (!xd->mode_info_context->mbmi.encoded_as_sb || orig_skip_flag)
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
skip_recon_mb(pbi, xd);
|
|
|
|
return;
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-07-20 23:21:24 +02:00
|
|
|
|
2011-12-01 01:25:00 +01:00
|
|
|
#ifdef DEC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (dec_debug) {
|
|
|
|
int i, j;
|
|
|
|
printf("Generating predictors\n");
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
for (j = 0; j < 16; j++) printf("%3d ", xd->dst.y_buffer[i * xd->dst.y_stride + j]);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
2011-12-01 01:25:00 +01:00
|
|
|
#endif
|
|
|
|
|
2012-08-16 22:25:49 +02:00
|
|
|
// moved to be performed before detokenization
|
|
|
|
// if (xd->segmentation_enabled)
|
|
|
|
// mb_init_dequantizer(pbi, xd);
|
2010-05-28 20:28:12 +02:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
|
2012-06-25 21:26:09 +02:00
|
|
|
// parse transform types for intra 4x4 mode
|
2012-08-16 22:25:49 +02:00
|
|
|
QIndex = xd->q_index;
|
|
|
|
active_ht = (QIndex < ACTIVE_HT);
|
2012-06-25 21:26:09 +02:00
|
|
|
if (mode == B_PRED) {
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
BLOCKD *b = &xd->block[i];
|
|
|
|
int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
|
2012-08-02 18:07:33 +02:00
|
|
|
if(active_ht)
|
|
|
|
txfm_map(b, b_mode);
|
2012-06-25 21:26:09 +02:00
|
|
|
} // loop over 4x4 blocks
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM16X16
|
|
|
|
active_ht16 = (QIndex < ACTIVE_HT16);
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* do prediction */
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sby_s)(xd);
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sbuv_s)(xd);
|
|
|
|
} else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (mode != I8X8_PRED) {
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd);
|
|
|
|
if (mode != B_PRED) {
|
|
|
|
RECON_INVOKE(&pbi->common.rtcd.recon,
|
|
|
|
build_intra_predictors_mby)(xd);
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
#if 0
|
2012-07-14 00:21:29 +02:00
|
|
|
// Intra-modes requiring recon data from top-right
|
|
|
|
// MB have been temporarily disabled.
|
|
|
|
else {
|
|
|
|
vp8_intra_prediction_down_copy(xd);
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
vp8_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride, xd->dst.uv_stride);
|
|
|
|
} else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_build_inter_predictors_mb(xd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dequantization and idct */
|
|
|
|
if (mode == I8X8_PRED) {
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int ib = vp8_i8x8_block[i];
|
2012-08-18 00:37:51 +02:00
|
|
|
#if !CONFIG_HYBRIDTRANSFORM8X8
|
2012-07-14 00:21:29 +02:00
|
|
|
const int iblock[4] = {0, 1, 4, 5};
|
|
|
|
int j;
|
2012-08-18 00:37:51 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
int i8x8mode;
|
|
|
|
BLOCKD *b;
|
|
|
|
|
2012-08-02 18:07:33 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
2012-08-01 19:18:25 +02:00
|
|
|
int idx = (ib & 0x02) ? (ib + 2) : ib;
|
|
|
|
|
|
|
|
short *q = xd->block[idx].qcoeff;
|
|
|
|
short *dq = xd->block[0].dequant;
|
|
|
|
unsigned char *pre = xd->block[ib].predictor;
|
|
|
|
unsigned char *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
|
|
|
|
int stride = xd->dst.y_stride;
|
|
|
|
|
|
|
|
tx_type = TX_4X4;
|
|
|
|
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
b = &xd->block[ib];
|
|
|
|
i8x8mode = b->bmi.as_mode.first;
|
|
|
|
RECON_INVOKE(RTCD_VTABLE(recon), intra8x8_predict)
|
|
|
|
(b, i8x8mode, b->predictor);
|
|
|
|
|
2012-08-02 18:07:33 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM8X8
|
|
|
|
txfm_map(b, pred_mode_conv(i8x8mode));
|
|
|
|
vp8_ht_dequant_idct_add_8x8_c(b->bmi.as_mode.tx_type,
|
|
|
|
q, dq, pre, dst, 16, stride);
|
2012-08-01 19:18:25 +02:00
|
|
|
q += 64;
|
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
|
b = &xd->block[ib + iblock[j]];
|
|
|
|
if (xd->eobs[ib + iblock[j]] > 1) {
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add)
|
|
|
|
(b->qcoeff, b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
} else {
|
|
|
|
IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
|
|
|
|
(b->qcoeff[0] * b->dequant[0], b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
((int *)b->qcoeff)[0] = 0;
|
2011-08-05 01:30:27 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-08-01 19:18:25 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
b = &xd->block[16 + i];
|
|
|
|
RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)
|
|
|
|
(b, i8x8mode, b->predictor);
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add)
|
|
|
|
(b->qcoeff, b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 8, b->dst_stride);
|
|
|
|
b = &xd->block[20 + i];
|
|
|
|
RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)
|
|
|
|
(b, i8x8mode, b->predictor);
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add)
|
|
|
|
(b->qcoeff, b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 8, b->dst_stride);
|
2011-08-05 01:30:27 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (mode == B_PRED) {
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
BLOCKD *b = &xd->block[i];
|
|
|
|
int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
|
2012-02-29 02:12:08 +01:00
|
|
|
#if CONFIG_COMP_INTRA_PRED
|
2012-07-14 00:21:29 +02:00
|
|
|
int b_mode2 = xd->mode_info_context->bmi[i].as_mode.second;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
|
2012-02-29 02:12:08 +01:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict)
|
|
|
|
(b, b_mode, b->predictor);
|
2012-02-29 02:12:08 +01:00
|
|
|
#if CONFIG_COMP_INTRA_PRED
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
RECON_INVOKE(RTCD_VTABLE(recon), comp_intra4x4_predict)
|
|
|
|
(b, b_mode, b_mode2, b->predictor);
|
|
|
|
}
|
2012-02-29 02:12:08 +01:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-06-25 21:26:09 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM
|
|
|
|
if(active_ht)
|
|
|
|
vp8_ht_dequant_idct_add_c( (TX_TYPE)b->bmi.as_mode.tx_type, b->qcoeff,
|
|
|
|
b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
else
|
|
|
|
vp8_dequant_idct_add_c(b->qcoeff, b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
#else
|
|
|
|
if (xd->eobs[i] > 1)
|
|
|
|
{
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add)
|
|
|
|
(b->qcoeff, b->dequant, b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
|
|
|
|
(b->qcoeff[0] * b->dequant[0], b->predictor,
|
|
|
|
*(b->base_dst) + b->dst, 16, b->dst_stride);
|
|
|
|
((int *)b->qcoeff)[0] = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-06-25 21:26:09 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (mode == SPLITMV) {
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add_y_block)
|
|
|
|
(xd->qcoeff, xd->block[0].dequant,
|
|
|
|
xd->predictor, xd->dst.y_buffer,
|
|
|
|
xd->dst.y_stride, xd->eobs);
|
|
|
|
} else {
|
|
|
|
BLOCKD *b = &xd->block[24];
|
2012-08-03 02:03:14 +02:00
|
|
|
|
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-29 20:25:38 +02:00
|
|
|
#if CONFIG_HYBRIDTRANSFORM16X16
|
|
|
|
if (mode < I8X8_PRED && active_ht16) {
|
|
|
|
BLOCKD *bd = &xd->block[0];
|
|
|
|
TX_TYPE txfm;
|
|
|
|
txfm_map(bd, pred_mode_conv(mode));
|
|
|
|
txfm = bd->bmi.as_mode.tx_type;
|
|
|
|
|
|
|
|
vp8_ht_dequant_idct_add_16x16_c(txfm, xd->qcoeff,
|
|
|
|
xd->block[0].dequant, xd->predictor,
|
|
|
|
xd->dst.y_buffer, 16, xd->dst.y_stride);
|
|
|
|
} else {
|
|
|
|
vp8_dequant_idct_add_16x16_c(xd->qcoeff, xd->block[0].dequant,
|
|
|
|
xd->predictor, xd->dst.y_buffer,
|
|
|
|
16, xd->dst.y_stride);
|
|
|
|
}
|
|
|
|
#else
|
2012-08-03 02:03:14 +02:00
|
|
|
vp8_dequant_idct_add_16x16_c(xd->qcoeff, xd->block[0].dequant,
|
|
|
|
xd->predictor, xd->dst.y_buffer,
|
|
|
|
16, xd->dst.y_stride);
|
2012-08-29 20:25:38 +02:00
|
|
|
#endif
|
2012-08-03 02:03:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (tx_type == TX_8X8) {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
void *orig = xd->mode_info_context;
|
|
|
|
int n, num = xd->mode_info_context->mbmi.encoded_as_sb ? 4 : 1;
|
|
|
|
for (n = 0; n < num; n++) {
|
|
|
|
if (n != 0) {
|
|
|
|
for (i = 0; i < 25; i++) {
|
|
|
|
xd->block[i].eob = 0;
|
|
|
|
xd->eobs[i] = 0;
|
|
|
|
}
|
|
|
|
xd->above_context = pc->above_context + mb_col + (n & 1);
|
|
|
|
xd->left_context = pc->left_context + (n >> 1);
|
|
|
|
xd->mode_info_context = orig;
|
|
|
|
xd->mode_info_context += (n & 1);
|
|
|
|
xd->mode_info_context += (n >> 1) * pc->mode_info_stride;
|
|
|
|
if (!orig_skip_flag) {
|
|
|
|
eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd);
|
|
|
|
if (eobtotal == 0) // skip loopfilter
|
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = 1;
|
|
|
|
} else {
|
|
|
|
vp8_reset_mb_tokens_context(xd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.mb_skip_coeff)
|
|
|
|
continue; // only happens for SBs, which are already in dest buffer
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
DEQUANT_INVOKE(&pbi->dequant, block_2x2)(b);
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef DEC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (dec_debug) {
|
|
|
|
int j;
|
|
|
|
printf("DQcoeff Haar\n");
|
|
|
|
for (j = 0; j < 16; j++) {
|
|
|
|
printf("%d ", b->dqcoeff[j]);
|
2011-10-09 00:48:53 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
IDCT_INVOKE(RTCD_VTABLE(idct), ihaar2)(&b->dqcoeff[0], b->diff, 8);
|
|
|
|
((int *)b->qcoeff)[0] = 0;// 2nd order block are set to 0 after inverse transform
|
|
|
|
((int *)b->qcoeff)[1] = 0;
|
|
|
|
((int *)b->qcoeff)[2] = 0;
|
|
|
|
((int *)b->qcoeff)[3] = 0;
|
|
|
|
((int *)b->qcoeff)[4] = 0;
|
|
|
|
((int *)b->qcoeff)[5] = 0;
|
|
|
|
((int *)b->qcoeff)[6] = 0;
|
|
|
|
((int *)b->qcoeff)[7] = 0;
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
vp8_dequant_dc_idct_add_y_block_8x8_inplace_c(xd->qcoeff,
|
|
|
|
xd->block[0].dequant,
|
|
|
|
xd->dst.y_buffer + (n >> 1) * 16 * xd->dst.y_stride + (n & 1) * 16,
|
|
|
|
xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
|
|
|
|
// do UV inline also
|
|
|
|
vp8_dequant_idct_add_uv_block_8x8_inplace_c(xd->qcoeff + 16 * 16,
|
|
|
|
xd->block[16].dequant,
|
|
|
|
xd->dst.u_buffer + (n >> 1) * 8 * xd->dst.uv_stride + (n & 1) * 8,
|
|
|
|
xd->dst.v_buffer + (n >> 1) * 8 * xd->dst.uv_stride + (n & 1) * 8,
|
|
|
|
xd->dst.uv_stride, xd->eobs + 16, xd);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, dc_idct_add_y_block_8x8)(xd->qcoeff,
|
|
|
|
xd->block[0].dequant, xd->predictor, xd->dst.y_buffer,
|
|
|
|
xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
}
|
|
|
|
xd->mode_info_context = orig;
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, block)(b);
|
|
|
|
if (xd->eobs[24] > 1) {
|
|
|
|
IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
|
|
|
|
((int *)b->qcoeff)[0] = 0;
|
|
|
|
((int *)b->qcoeff)[1] = 0;
|
|
|
|
((int *)b->qcoeff)[2] = 0;
|
|
|
|
((int *)b->qcoeff)[3] = 0;
|
|
|
|
((int *)b->qcoeff)[4] = 0;
|
|
|
|
((int *)b->qcoeff)[5] = 0;
|
|
|
|
((int *)b->qcoeff)[6] = 0;
|
|
|
|
((int *)b->qcoeff)[7] = 0;
|
|
|
|
} else {
|
|
|
|
IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
|
|
|
|
((int *)b->qcoeff)[0] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, dc_idct_add_y_block)
|
|
|
|
(xd->qcoeff, xd->block[0].dequant,
|
|
|
|
xd->predictor, xd->dst.y_buffer,
|
|
|
|
xd->dst.y_stride, xd->eobs, xd->block[24].diff);
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (!xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
#endif
|
|
|
|
if (tx_type == TX_8X8
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
|| tx_type == TX_16X16
|
|
|
|
#endif
|
|
|
|
)
|
2012-07-14 00:21:29 +02:00
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add_uv_block_8x8) //
|
|
|
|
(xd->qcoeff + 16 * 16, xd->block[16].dequant,
|
|
|
|
xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.uv_stride, xd->eobs + 16, xd); //
|
|
|
|
else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
|
|
|
|
DEQUANT_INVOKE(&pbi->dequant, idct_add_uv_block)
|
|
|
|
(xd->qcoeff + 16 * 16, xd->block[16].dequant,
|
|
|
|
xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.uv_stride, xd->eobs + 16);
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
}
|
|
|
|
#endif
|
2011-07-20 23:21:24 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2010-09-16 20:08:52 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static int get_delta_q(vp8_reader *bc, int prev, int *q_update) {
|
|
|
|
int ret_val = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
ret_val = vp8_read_literal(bc, 4);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read_bit(bc))
|
|
|
|
ret_val = -ret_val;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Trigger a quantizer update if the delta-q value has changed */
|
|
|
|
if (ret_val != prev)
|
|
|
|
*q_update = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return ret_val;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef PACKET_TESTING
|
|
|
|
#include <stdio.h>
|
|
|
|
FILE *vpxlog = 0;
|
|
|
|
#endif
|
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
/* Decode a row of Superblocks (2x2 region of MBs) */
|
2011-03-17 22:07:59 +01:00
|
|
|
static void
|
2012-07-14 00:21:29 +02:00
|
|
|
decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) {
|
|
|
|
int i;
|
|
|
|
int sb_col;
|
|
|
|
int mb_row, mb_col;
|
|
|
|
int recon_yoffset, recon_uvoffset;
|
|
|
|
int ref_fb_idx = pc->lst_fb_idx;
|
|
|
|
int dst_fb_idx = pc->new_fb_idx;
|
|
|
|
int recon_y_stride = pc->yv12_fb[ref_fb_idx].y_stride;
|
|
|
|
int recon_uv_stride = pc->yv12_fb[ref_fb_idx].uv_stride;
|
|
|
|
int row_delta[4] = { 0, +1, 0, -1};
|
|
|
|
int col_delta[4] = { +1, -1, +1, +1};
|
|
|
|
int sb_cols = (pc->mb_cols + 1) >> 1;
|
|
|
|
|
|
|
|
// For a SB there are 2 left contexts, each pertaining to a MB row within
|
2012-08-20 23:43:34 +02:00
|
|
|
vpx_memset(pc->left_context, 0, sizeof(pc->left_context));
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
mb_row = mbrow;
|
|
|
|
mb_col = 0;
|
|
|
|
|
|
|
|
for (sb_col = 0; sb_col < sb_cols; sb_col++) {
|
2012-08-20 23:43:34 +02:00
|
|
|
MODE_INFO *mi = xd->mode_info_context;
|
|
|
|
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (pbi->interleaved_decoding)
|
|
|
|
mi->mbmi.encoded_as_sb = vp8_read(&pbi->bc, pc->sb_coded);
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Process the 4 MBs within the SB in the order:
|
|
|
|
// top-left, top-right, bottom-left, bottom-right
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int dy = row_delta[i];
|
|
|
|
int dx = col_delta[i];
|
|
|
|
int offset_extended = dy * xd->mode_info_stride + dx;
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
mi = xd->mode_info_context;
|
2012-07-14 00:21:29 +02:00
|
|
|
if ((mb_row >= pc->mb_rows) || (mb_col >= pc->mb_cols)) {
|
|
|
|
// MB lies outside frame, skip on to next
|
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
|
|
|
xd->mode_info_context += offset_extended;
|
2012-08-03 21:31:38 +02:00
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2012-07-14 00:21:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
2011-12-07 22:03:57 +01:00
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
#ifdef DEC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
dec_debug = (pc->current_video_frame == 0 && mb_row == 0 && mb_col == 0);
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Set above context pointer
|
|
|
|
xd->above_context = pc->above_context + mb_col;
|
2012-08-20 23:43:34 +02:00
|
|
|
xd->left_context = pc->left_context + (i >> 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/* Distance of Mb to the various image edges.
|
|
|
|
* These are specified to 8th pel as they are always compared to
|
|
|
|
* values that are in 1/8th pel units
|
|
|
|
*/
|
|
|
|
xd->mb_to_top_edge = -((mb_row * 16)) << 3;
|
|
|
|
xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
|
|
|
|
|
|
|
|
xd->mb_to_left_edge = -((mb_col * 16) << 3);
|
|
|
|
xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
|
|
|
|
|
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
|
|
|
|
|
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
|
|
|
|
recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
|
|
|
|
|
|
|
|
xd->dst.y_buffer = pc->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
|
|
|
|
xd->dst.u_buffer = pc->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
|
|
|
|
xd->dst.v_buffer = pc->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (i)
|
|
|
|
mi->mbmi.encoded_as_sb = 0;
|
|
|
|
#endif
|
2012-08-06 19:51:20 +02:00
|
|
|
if(pbi->interleaved_decoding)
|
|
|
|
vpx_decode_mb_mode_mv(pbi, xd, mb_row, mb_col);
|
|
|
|
|
|
|
|
update_blockd_bmi(xd);
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Select the appropriate reference frame for this MB */
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
|
|
|
|
ref_fb_idx = pc->lst_fb_idx;
|
|
|
|
else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
|
|
|
|
ref_fb_idx = pc->gld_fb_idx;
|
|
|
|
else
|
|
|
|
ref_fb_idx = pc->alt_fb_idx;
|
|
|
|
|
|
|
|
xd->pre.y_buffer = pc->yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
|
|
|
|
xd->pre.u_buffer = pc->yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
|
|
|
|
xd->pre.v_buffer = pc->yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame) {
|
|
|
|
int second_ref_fb_idx;
|
|
|
|
|
|
|
|
/* Select the appropriate reference frame for this MB */
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
|
|
|
|
second_ref_fb_idx = pc->lst_fb_idx;
|
|
|
|
else if (xd->mode_info_context->mbmi.second_ref_frame ==
|
|
|
|
GOLDEN_FRAME)
|
|
|
|
second_ref_fb_idx = pc->gld_fb_idx;
|
|
|
|
else
|
|
|
|
second_ref_fb_idx = pc->alt_fb_idx;
|
|
|
|
|
|
|
|
xd->second_pre.y_buffer =
|
|
|
|
pc->yv12_fb[second_ref_fb_idx].y_buffer + recon_yoffset;
|
|
|
|
xd->second_pre.u_buffer =
|
|
|
|
pc->yv12_fb[second_ref_fb_idx].u_buffer + recon_uvoffset;
|
|
|
|
xd->second_pre.v_buffer =
|
|
|
|
pc->yv12_fb[second_ref_fb_idx].v_buffer + recon_uvoffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME) {
|
|
|
|
/* propagate errors from reference frames */
|
|
|
|
xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
|
|
|
|
}
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
mi[1] = mi[0];
|
|
|
|
mi[pc->mode_info_stride] = mi[0];
|
|
|
|
mi[pc->mode_info_stride + 1] = mi[0];
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
decode_macroblock(pbi, xd, mb_col);
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
mi[1].mbmi.txfm_size = mi[0].mbmi.txfm_size;
|
|
|
|
mi[pc->mode_info_stride].mbmi.txfm_size = mi[0].mbmi.txfm_size;
|
|
|
|
mi[pc->mode_info_stride + 1].mbmi.txfm_size = mi[0].mbmi.txfm_size;
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/* check if the boolean decoder has suffered an error */
|
|
|
|
xd->corrupted |= vp8dx_bool_error(xd->current_bc);
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (mi->mbmi.encoded_as_sb) {
|
|
|
|
assert(!i);
|
|
|
|
mb_col += 2;
|
|
|
|
xd->mode_info_context += 2;
|
|
|
|
xd->prev_mode_info_context += 2;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// skip to next MB
|
|
|
|
xd->mode_info_context += offset_extended;
|
2012-08-03 21:31:38 +02:00
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2012-07-14 00:21:29 +02:00
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* skip prediction column */
|
|
|
|
xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
|
2012-08-03 21:31:38 +02:00
|
|
|
xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static unsigned int read_partition_size(const unsigned char *cx_size) {
|
|
|
|
const unsigned int size =
|
|
|
|
cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
|
|
|
|
return size;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2011-08-05 18:27:25 +02:00
|
|
|
static int read_is_valid(const unsigned char *start,
|
|
|
|
size_t len,
|
2012-07-14 00:21:29 +02:00
|
|
|
const unsigned char *end) {
|
|
|
|
return (start + len > start && start + len <= end);
|
2011-08-05 18:27:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
static void setup_token_decoder(VP8D_COMP *pbi,
|
2012-07-14 00:21:29 +02:00
|
|
|
const unsigned char *cx_data) {
|
|
|
|
VP8_COMMON *pc = &pbi->common;
|
|
|
|
const unsigned char *user_data_end = pbi->Source + pbi->source_sz;
|
|
|
|
vp8_reader *bool_decoder;
|
|
|
|
const unsigned char *partition;
|
|
|
|
|
|
|
|
ptrdiff_t partition_size;
|
|
|
|
ptrdiff_t bytes_left;
|
|
|
|
|
|
|
|
// Dummy read for now
|
|
|
|
vp8_read_literal(&pbi->bc, 2);
|
|
|
|
|
|
|
|
// Set up pointers to token partition
|
|
|
|
partition = cx_data;
|
|
|
|
bool_decoder = &pbi->bc2;
|
|
|
|
bytes_left = user_data_end - partition;
|
|
|
|
partition_size = bytes_left;
|
|
|
|
|
|
|
|
/* Validate the calculated partition length. If the buffer
|
|
|
|
* described by the partition can't be fully read, then restrict
|
|
|
|
* it to the portion that can be (for EC mode) or throw an error.
|
|
|
|
*/
|
|
|
|
if (!read_is_valid(partition, partition_size, user_data_end)) {
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"Truncated packet or corrupt partition "
|
|
|
|
"%d length", 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vp8dx_start_decode(bool_decoder, partition, partition_size))
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
|
|
|
|
"Failed to allocate bool decoder %d", 1);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void init_frame(VP8D_COMP *pbi) {
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
MACROBLOCKD *const xd = & pbi->mb;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pc->frame_type == KEY_FRAME) {
|
|
|
|
/* Various keyframe initializations */
|
|
|
|
vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
|
|
|
|
vpx_memcpy(pc->fc.mvc_hp, vp8_default_mv_context_hp,
|
|
|
|
sizeof(vp8_default_mv_context_hp));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_init_mbmode_probs(pc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_default_coef_probs(pc);
|
|
|
|
vp8_kf_default_bmode_probs(pc->kf_bmode_prob);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Reset the segment feature data to the default stats:
|
|
|
|
// Features disabled, 0, with delta coding (Default state).
|
|
|
|
clearall_segfeatures(xd);
|
2011-09-14 19:20:25 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* reset the mode ref deltasa for loop filter */
|
|
|
|
vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
|
|
|
|
vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* All buffers are implicitly updated on key frames. */
|
|
|
|
pc->refresh_golden_frame = 1;
|
|
|
|
pc->refresh_alt_ref_frame = 1;
|
|
|
|
pc->copy_buffer_to_gf = 0;
|
|
|
|
pc->copy_buffer_to_arf = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Note that Golden and Altref modes cannot be used on a key frame so
|
|
|
|
* ref_frame_sign_bias[] is undefined and meaningless
|
|
|
|
*/
|
|
|
|
pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
|
|
|
|
pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
|
2011-12-01 01:36:46 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_init_mode_contexts(&pbi->common);
|
|
|
|
vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
|
|
|
|
vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
|
2011-12-07 22:55:58 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(pbi->common.fc.vp8_mode_contexts,
|
|
|
|
pbi->common.fc.mode_context,
|
|
|
|
sizeof(pbi->common.fc.mode_context));
|
|
|
|
} else {
|
2011-12-01 01:36:46 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!pc->use_bilinear_mc_filter)
|
|
|
|
pc->mcomp_filter_type = EIGHTTAP;
|
|
|
|
else
|
|
|
|
pc->mcomp_filter_type = BILINEAR;
|
|
|
|
|
2012-07-28 02:46:33 +02:00
|
|
|
/* To enable choice of different interpolation filters */
|
2012-07-18 22:43:01 +02:00
|
|
|
vp8_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context = pc->mi;
|
2012-08-03 21:31:38 +02:00
|
|
|
xd->prev_mode_info_context = pc->prev_mi;
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->frame_type = pc->frame_type;
|
|
|
|
xd->mode_info_context->mbmi.mode = DC_PRED;
|
|
|
|
xd->mode_info_stride = pc->mode_info_stride;
|
|
|
|
xd->corrupted = 0; /* init without corruption */
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->fullpixel_mask = 0xffffffff;
|
|
|
|
if (pc->full_pixel)
|
|
|
|
xd->fullpixel_mask = 0xfffffff8;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void read_coef_probs2(VP8D_COMP *pbi) {
|
|
|
|
const vp8_prob grpupd = 192;
|
|
|
|
int i, j, k, l;
|
|
|
|
vp8_reader *const bc = & pbi->bc;
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
for (l = 0; l < ENTROPY_NODES; l++) {
|
|
|
|
if (vp8_read(bc, grpupd)) {
|
|
|
|
// printf("Decoding %d\n", l);
|
|
|
|
for (i = 0; i < BLOCK_TYPES; i++)
|
|
|
|
for (j = !i; j < COEF_BANDS; j++)
|
|
|
|
for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
|
|
|
|
if (k >= 3 && ((i == 0 && j == 1) ||
|
|
|
|
(i > 0 && j == 0)))
|
|
|
|
continue;
|
2012-04-12 18:24:03 +02:00
|
|
|
{
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_prob *const p = pc->fc.coef_probs [i][j][k] + l;
|
|
|
|
int u = vp8_read(bc, COEF_UPDATE_PROB);
|
|
|
|
if (u) *p = read_prob_diff_update(bc, *p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pbi->common.txfm_mode == ALLOW_8X8) {
|
|
|
|
for (l = 0; l < ENTROPY_NODES; l++) {
|
|
|
|
if (vp8_read(bc, grpupd)) {
|
|
|
|
for (i = 0; i < BLOCK_TYPES_8X8; i++)
|
|
|
|
for (j = !i; j < COEF_BANDS; j++)
|
|
|
|
for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
|
|
|
|
if (k >= 3 && ((i == 0 && j == 1) ||
|
|
|
|
(i > 0 && j == 0)))
|
|
|
|
continue;
|
|
|
|
{
|
|
|
|
vp8_prob *const p = pc->fc.coef_probs_8x8 [i][j][k] + l;
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int u = vp8_read(bc, COEF_UPDATE_PROB_8X8);
|
|
|
|
if (u) *p = read_prob_diff_update(bc, *p);
|
|
|
|
}
|
2012-04-12 18:24:03 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-12 18:24:03 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-12 18:24:03 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void read_coef_probs(VP8D_COMP *pbi) {
|
|
|
|
int i, j, k, l;
|
|
|
|
vp8_reader *const bc = & pbi->bc;
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
|
|
|
|
{
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
/* read coef probability tree */
|
|
|
|
for (i = 0; i < BLOCK_TYPES; i++)
|
|
|
|
for (j = !i; j < COEF_BANDS; j++)
|
|
|
|
for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
|
|
|
|
if (k >= 3 && ((i == 0 && j == 1) ||
|
|
|
|
(i > 0 && j == 0)))
|
|
|
|
continue;
|
|
|
|
for (l = 0; l < ENTROPY_NODES; l++) {
|
|
|
|
vp8_prob *const p = pc->fc.coef_probs [i][j][k] + l;
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read(bc, COEF_UPDATE_PROB)) {
|
|
|
|
*p = read_prob_diff_update(bc, *p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 02:03:14 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pbi->common.txfm_mode == ALLOW_8X8 && vp8_read_bit(bc)) {
|
|
|
|
// read coef probability tree
|
|
|
|
for (i = 0; i < BLOCK_TYPES_8X8; i++)
|
|
|
|
for (j = !i; j < COEF_BANDS; j++)
|
|
|
|
for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
|
|
|
|
if (k >= 3 && ((i == 0 && j == 1) ||
|
|
|
|
(i > 0 && j == 0)))
|
|
|
|
continue;
|
|
|
|
for (l = 0; l < ENTROPY_NODES; l++) {
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_prob *const p = pc->fc.coef_probs_8x8 [i][j][k] + l;
|
2012-04-12 18:24:03 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read(bc, COEF_UPDATE_PROB_8X8)) {
|
|
|
|
*p = read_prob_diff_update(bc, *p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 02:03:14 +02:00
|
|
|
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
// 16x16
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
// read coef probability tree
|
|
|
|
for (i = 0; i < BLOCK_TYPES_16X16; ++i)
|
|
|
|
for (j = !i; j < COEF_BANDS; ++j)
|
|
|
|
for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
|
|
|
|
if (k >= 3 && ((i == 0 && j == 1) ||
|
|
|
|
(i > 0 && j == 0)))
|
|
|
|
continue;
|
|
|
|
for (l = 0; l < ENTROPY_NODES; ++l) {
|
|
|
|
|
|
|
|
vp8_prob *const p = pc->fc.coef_probs_16x16[i][j][k] + l;
|
|
|
|
|
|
|
|
if (vp8_read(bc, COEF_UPDATE_PROB_16X16)) {
|
|
|
|
*p = read_prob_diff_update(bc, *p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2012-04-12 18:24:03 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int vp8_decode_frame(VP8D_COMP *pbi) {
|
|
|
|
vp8_reader *const bc = & pbi->bc;
|
|
|
|
VP8_COMMON *const pc = & pbi->common;
|
|
|
|
MACROBLOCKD *const xd = & pbi->mb;
|
|
|
|
const unsigned char *data = (const unsigned char *)pbi->Source;
|
|
|
|
const unsigned char *data_end = data + pbi->source_sz;
|
|
|
|
ptrdiff_t first_partition_length_in_bytes = 0;
|
|
|
|
|
|
|
|
int mb_row;
|
|
|
|
int i, j;
|
|
|
|
int corrupt_tokens = 0;
|
|
|
|
|
|
|
|
/* start with no corruption of current frame */
|
|
|
|
xd->corrupted = 0;
|
|
|
|
pc->yv12_fb[pc->new_fb_idx].corrupted = 0;
|
|
|
|
|
|
|
|
if (data_end - data < 3) {
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"Truncated packet");
|
|
|
|
} else {
|
|
|
|
pc->last_frame_type = pc->frame_type;
|
|
|
|
pc->frame_type = (FRAME_TYPE)(data[0] & 1);
|
|
|
|
pc->version = (data[0] >> 1) & 7;
|
|
|
|
pc->show_frame = (data[0] >> 4) & 1;
|
|
|
|
first_partition_length_in_bytes =
|
|
|
|
(data[0] | (data[1] << 8) | (data[2] << 16)) >> 5;
|
|
|
|
|
|
|
|
if ((data + first_partition_length_in_bytes > data_end
|
|
|
|
|| data + first_partition_length_in_bytes < data))
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"Truncated packet or corrupt partition 0 length");
|
|
|
|
|
|
|
|
data += 3;
|
|
|
|
|
|
|
|
vp8_setup_version(pc);
|
2011-07-20 23:21:24 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pc->frame_type == KEY_FRAME) {
|
|
|
|
const int Width = pc->Width;
|
|
|
|
const int Height = pc->Height;
|
|
|
|
|
|
|
|
/* vet via sync code */
|
|
|
|
/* When error concealment is enabled we should only check the sync
|
|
|
|
* code if we have enough bits available
|
|
|
|
*/
|
|
|
|
if (data + 3 < data_end) {
|
|
|
|
if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
|
|
|
|
"Invalid frame sync code");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If error concealment is enabled we should only parse the new size
|
|
|
|
* if we have enough data. Otherwise we will end up with the wrong
|
|
|
|
* size.
|
|
|
|
*/
|
|
|
|
if (data + 6 < data_end) {
|
|
|
|
pc->Width = (data[3] | (data[4] << 8)) & 0x3fff;
|
|
|
|
pc->horiz_scale = data[4] >> 6;
|
|
|
|
pc->Height = (data[5] | (data[6] << 8)) & 0x3fff;
|
|
|
|
pc->vert_scale = data[6] >> 6;
|
|
|
|
}
|
|
|
|
data += 7;
|
|
|
|
|
|
|
|
if (Width != pc->Width || Height != pc->Height) {
|
|
|
|
if (pc->Width <= 0) {
|
|
|
|
pc->Width = Width;
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"Invalid frame width");
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pc->Height <= 0) {
|
|
|
|
pc->Height = Height;
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"Invalid frame height");
|
|
|
|
}
|
2010-12-16 16:46:31 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
|
|
|
|
"Failed to allocate frame buffers");
|
|
|
|
}
|
2011-05-02 15:30:51 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
|
|
|
|
pc->Width == 0 || pc->Height == 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
2011-05-02 15:30:51 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
init_frame(pbi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8dx_start_decode(bc, data, data_end - data))
|
|
|
|
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
|
|
|
|
"Failed to allocate bool decoder 0");
|
|
|
|
if (pc->frame_type == KEY_FRAME) {
|
|
|
|
pc->clr_type = (YUV_TYPE)vp8_read_bit(bc);
|
|
|
|
pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Is segmentation enabled */
|
|
|
|
xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (xd->segmentation_enabled) {
|
|
|
|
// Read whether or not the segmentation map is being explicitly
|
|
|
|
// updated this frame.
|
|
|
|
xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// If so what method will be used.
|
|
|
|
if (xd->update_mb_segmentation_map)
|
|
|
|
pc->temporal_update = (unsigned char)vp8_read_bit(bc);
|
2012-02-16 18:29:54 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Is the segment data being updated
|
|
|
|
xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);
|
2011-11-11 11:10:06 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (xd->update_mb_segmentation_data) {
|
|
|
|
int data;
|
2011-11-11 11:10:06 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mb_segment_abs_delta = (unsigned char)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
clearall_segfeatures(xd);
|
2011-11-03 13:50:09 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// For each segmentation...
|
|
|
|
for (i = 0; i < MAX_MB_SEGMENTS; i++) {
|
|
|
|
// For each of the segments features...
|
|
|
|
for (j = 0; j < SEG_LVL_MAX; j++) {
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
#if CONFIG_FEATUREUPDATES
|
|
|
|
// feature updated?
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
int active = 1;
|
2011-09-14 19:20:25 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (segfeature_active(xd, i, j))
|
|
|
|
active = vp8_read_bit(bc);
|
2012-02-13 17:21:24 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Is the feature enabled
|
|
|
|
if (active) {
|
|
|
|
// Update the feature data and mask
|
|
|
|
enable_segfeature(xd, i, j);
|
2012-02-13 17:21:24 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
data = (signed char)vp8_read_literal(
|
|
|
|
bc, seg_feature_data_bits(j));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Is the segment data signed..
|
|
|
|
if (is_segfeature_signed(j)) {
|
2010-05-18 17:58:33 +02:00
|
|
|
if (vp8_read_bit(bc))
|
2012-07-14 00:21:29 +02:00
|
|
|
data = - data;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
data = 0;
|
2011-11-15 17:15:23 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
set_segdata(xd, i, j, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
// Is the feature enabled
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
// Update the feature data and mask
|
|
|
|
enable_segfeature(xd, i, j);
|
|
|
|
|
|
|
|
data = (signed char)vp8_read_literal(
|
|
|
|
bc, seg_feature_data_bits(j));
|
|
|
|
|
|
|
|
// Is the segment data signed..
|
|
|
|
if (is_segfeature_signed(j)) {
|
|
|
|
if (vp8_read_bit(bc))
|
|
|
|
data = - data;
|
2011-11-15 12:13:33 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else
|
|
|
|
data = 0;
|
|
|
|
|
|
|
|
set_segdata(xd, i, j, data);
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (xd->update_mb_segmentation_map) {
|
|
|
|
// Which macro block level features are enabled
|
|
|
|
vpx_memset(xd->mb_segment_tree_probs, 255,
|
|
|
|
sizeof(xd->mb_segment_tree_probs));
|
|
|
|
vpx_memset(pc->segment_pred_probs, 255,
|
|
|
|
sizeof(pc->segment_pred_probs));
|
|
|
|
|
|
|
|
// Read the probs used to decode the segment id for each macro
|
|
|
|
// block.
|
|
|
|
for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) {
|
|
|
|
// If not explicitly set value is defaulted to 255 by
|
|
|
|
// memset above
|
|
|
|
if (vp8_read_bit(bc))
|
|
|
|
xd->mb_segment_tree_probs[i] =
|
|
|
|
(vp8_prob)vp8_read_literal(bc, 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If predictive coding of segment map is enabled read the
|
|
|
|
// prediction probabilities.
|
|
|
|
if (pc->temporal_update) {
|
|
|
|
// Read the prediction probs needed to decode the segment id
|
|
|
|
// when predictive coding enabled
|
|
|
|
for (i = 0; i < PREDICTION_PROBS; i++) {
|
|
|
|
// If not explicitly set value is defaulted to 255 by
|
|
|
|
// memset above
|
|
|
|
if (vp8_read_bit(bc))
|
|
|
|
pc->segment_pred_probs[i] =
|
|
|
|
(vp8_prob)vp8_read_literal(bc, 8);
|
2012-01-28 13:20:14 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-01-28 13:20:14 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read common prediction model status flag probability updates for the
|
|
|
|
// reference frame
|
|
|
|
if (pc->frame_type == KEY_FRAME) {
|
|
|
|
// Set the prediction probabilities to defaults
|
|
|
|
pc->ref_pred_probs[0] = 120;
|
|
|
|
pc->ref_pred_probs[1] = 80;
|
|
|
|
pc->ref_pred_probs[2] = 40;
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < PREDICTION_PROBS; i++) {
|
|
|
|
if (vp8_read_bit(bc))
|
|
|
|
pc->ref_pred_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
|
|
|
|
}
|
|
|
|
}
|
2012-01-28 13:20:14 +01:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
pc->sb_coded = vp8_read_literal(bc, 8);
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Read the loop filter level and type */
|
|
|
|
pc->txfm_mode = (TXFM_MODE) vp8_read_bit(bc);
|
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
|
|
|
pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
|
|
|
|
pc->filter_level = vp8_read_literal(bc, 6);
|
|
|
|
pc->sharpness_level = vp8_read_literal(bc, 3);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
|
|
|
|
xd->mode_ref_lf_delta_update = 0;
|
|
|
|
xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (xd->mode_ref_lf_delta_enabled) {
|
|
|
|
/* Do the deltas need to be updated */
|
|
|
|
xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (xd->mode_ref_lf_delta_update) {
|
|
|
|
/* Send update */
|
|
|
|
for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
/*sign = vp8_read_bit( bc );*/
|
|
|
|
xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read_bit(bc)) /* Apply sign */
|
|
|
|
xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Send update */
|
|
|
|
for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
/*sign = vp8_read_bit( bc );*/
|
|
|
|
xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (vp8_read_bit(bc)) /* Apply sign */
|
|
|
|
xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
setup_token_decoder(pbi, data + first_partition_length_in_bytes);
|
|
|
|
|
|
|
|
xd->current_bc = &pbi->bc2;
|
|
|
|
|
|
|
|
/* Read the default quantizers. */
|
|
|
|
{
|
|
|
|
int Q, q_update;
|
|
|
|
|
|
|
|
Q = vp8_read_literal(bc, QINDEX_BITS); /* AC 1st order Q = default */
|
|
|
|
pc->base_qindex = Q;
|
|
|
|
q_update = 0;
|
|
|
|
pc->y1dc_delta_q = get_delta_q(bc, pc->y1dc_delta_q, &q_update);
|
|
|
|
pc->y2dc_delta_q = get_delta_q(bc, pc->y2dc_delta_q, &q_update);
|
|
|
|
pc->y2ac_delta_q = get_delta_q(bc, pc->y2ac_delta_q, &q_update);
|
|
|
|
pc->uvdc_delta_q = get_delta_q(bc, pc->uvdc_delta_q, &q_update);
|
|
|
|
pc->uvac_delta_q = get_delta_q(bc, pc->uvac_delta_q, &q_update);
|
|
|
|
|
|
|
|
if (q_update)
|
|
|
|
vp8cx_init_de_quantizer(pbi);
|
|
|
|
|
|
|
|
/* MB level dequantizer setup */
|
|
|
|
mb_init_dequantizer(pbi, &pbi->mb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine if the golden frame or ARF buffer should be updated and how.
|
|
|
|
* For all non key frames the GF and ARF refresh flags and sign bias
|
|
|
|
* flags must be set explicitly.
|
|
|
|
*/
|
|
|
|
if (pc->frame_type != KEY_FRAME) {
|
|
|
|
/* Should the GF or ARF be updated from the current frame */
|
|
|
|
pc->refresh_golden_frame = vp8_read_bit(bc);
|
|
|
|
pc->refresh_alt_ref_frame = vp8_read_bit(bc);
|
|
|
|
|
|
|
|
if (pc->refresh_alt_ref_frame) {
|
|
|
|
vpx_memcpy(&pc->fc, &pc->lfc_a, sizeof(pc->fc));
|
|
|
|
vpx_memcpy(pc->fc.vp8_mode_contexts,
|
|
|
|
pc->fc.mode_context_a,
|
|
|
|
sizeof(pc->fc.vp8_mode_contexts));
|
|
|
|
} else {
|
|
|
|
vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));
|
|
|
|
vpx_memcpy(pc->fc.vp8_mode_contexts,
|
|
|
|
pc->fc.mode_context,
|
|
|
|
sizeof(pc->fc.vp8_mode_contexts));
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Buffer to buffer copy flags. */
|
|
|
|
pc->copy_buffer_to_gf = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!pc->refresh_golden_frame)
|
|
|
|
pc->copy_buffer_to_gf = vp8_read_literal(bc, 2);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pc->copy_buffer_to_arf = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!pc->refresh_alt_ref_frame)
|
|
|
|
pc->copy_buffer_to_arf = vp8_read_literal(bc, 2);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bc);
|
|
|
|
pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bc);
|
2012-02-16 18:29:54 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Is high precision mv allowed */
|
|
|
|
xd->allow_high_precision_mv = (unsigned char)vp8_read_bit(bc);
|
|
|
|
// Read the type of subpel filter to use
|
2012-07-18 22:43:01 +02:00
|
|
|
#if CONFIG_SWITCHABLE_INTERP
|
|
|
|
if (vp8_read_bit(bc)) {
|
|
|
|
pc->mcomp_filter_type = SWITCHABLE;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
pc->mcomp_filter_type = vp8_read_literal(bc, 2);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-18 22:43:01 +02:00
|
|
|
/* To enable choice of different interploation filters */
|
|
|
|
vp8_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
pc->refresh_entropy_probs = vp8_read_bit(bc);
|
|
|
|
if (pc->refresh_entropy_probs == 0) {
|
|
|
|
vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
|
|
|
|
}
|
|
|
|
|
|
|
|
pc->refresh_last_frame = pc->frame_type == KEY_FRAME || vp8_read_bit(bc);
|
|
|
|
|
|
|
|
if (0) {
|
|
|
|
FILE *z = fopen("decodestats.stt", "a");
|
|
|
|
fprintf(z, "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\n",
|
|
|
|
pc->current_video_frame,
|
|
|
|
pc->frame_type,
|
|
|
|
pc->refresh_golden_frame,
|
|
|
|
pc->refresh_alt_ref_frame,
|
|
|
|
pc->refresh_last_frame,
|
|
|
|
pc->base_qindex);
|
|
|
|
fclose(z);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(pbi->common.fc.pre_coef_probs, pbi->common.fc.coef_probs);
|
|
|
|
vp8_copy(pbi->common.fc.pre_coef_probs_8x8, pbi->common.fc.coef_probs_8x8);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
vp8_copy(pbi->common.fc.pre_coef_probs_16x16, pbi->common.fc.coef_probs_16x16);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(pbi->common.fc.pre_ymode_prob, pbi->common.fc.ymode_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_uv_mode_prob, pbi->common.fc.uv_mode_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_bmode_prob, pbi->common.fc.bmode_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_i8x8_mode_prob, pbi->common.fc.i8x8_mode_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_sub_mv_ref_prob, pbi->common.fc.sub_mv_ref_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_mbsplit_prob, pbi->common.fc.mbsplit_prob);
|
|
|
|
vp8_copy(pbi->common.fc.pre_mvc, pbi->common.fc.mvc);
|
|
|
|
vp8_copy(pbi->common.fc.pre_mvc_hp, pbi->common.fc.mvc_hp);
|
|
|
|
vp8_zero(pbi->common.fc.coef_counts);
|
|
|
|
vp8_zero(pbi->common.fc.coef_counts_8x8);
|
2012-08-29 20:25:38 +02:00
|
|
|
#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
|
2012-08-03 02:03:14 +02:00
|
|
|
vp8_zero(pbi->common.fc.coef_counts_16x16);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_zero(pbi->common.fc.ymode_counts);
|
|
|
|
vp8_zero(pbi->common.fc.uv_mode_counts);
|
|
|
|
vp8_zero(pbi->common.fc.bmode_counts);
|
|
|
|
vp8_zero(pbi->common.fc.i8x8_mode_counts);
|
|
|
|
vp8_zero(pbi->common.fc.sub_mv_ref_counts);
|
|
|
|
vp8_zero(pbi->common.fc.mbsplit_counts);
|
|
|
|
vp8_zero(pbi->common.fc.MVcount);
|
|
|
|
vp8_zero(pbi->common.fc.MVcount_hp);
|
|
|
|
vp8_zero(pbi->common.fc.mv_ref_ct);
|
|
|
|
vp8_zero(pbi->common.fc.mv_ref_ct_a);
|
2012-07-27 20:29:46 +02:00
|
|
|
#if COEFUPDATETYPE == 2
|
2012-07-14 00:21:29 +02:00
|
|
|
read_coef_probs2(pbi);
|
2012-04-12 18:24:03 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
read_coef_probs(pbi);
|
2012-04-12 18:24:03 +02:00
|
|
|
#endif
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
|
|
|
|
vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Create the segmentation map structure and set to 0
|
|
|
|
if (!pc->last_frame_seg_map)
|
|
|
|
CHECK_MEM_ERROR(pc->last_frame_seg_map,
|
|
|
|
vpx_calloc((pc->mb_rows * pc->mb_cols), 1));
|
2010-09-24 00:25:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* set up frame new frame for intra coded blocks */
|
|
|
|
vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_setup_block_dptrs(xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_build_block_doffsets(xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* clear out the coeff buffer */
|
|
|
|
vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Read the mb_no_coeff_skip flag */
|
|
|
|
pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-03 21:31:38 +02:00
|
|
|
if(pbi->interleaved_decoding)
|
|
|
|
vpx_decode_mode_mvs_init(pbi);
|
|
|
|
else
|
|
|
|
vp8_decode_mode_mvs(pbi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Resset the macroblock mode info context to the start of the list
|
|
|
|
xd->mode_info_context = pc->mi;
|
2012-08-03 21:31:38 +02:00
|
|
|
xd->prev_mode_info_context = pc->prev_mi;
|
2012-01-28 11:24:43 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Decode a row of superblocks */
|
|
|
|
for (mb_row = 0; mb_row < pc->mb_rows; mb_row += 2) {
|
|
|
|
decode_sb_row(pbi, pc, mb_row, xd);
|
|
|
|
}
|
|
|
|
corrupt_tokens |= xd->corrupted;
|
|
|
|
|
|
|
|
/* Collect information about decoder corruption. */
|
|
|
|
/* 1. Check first boolean decoder for errors. */
|
|
|
|
pc->yv12_fb[pc->new_fb_idx].corrupted = vp8dx_bool_error(bc);
|
|
|
|
/* 2. Check the macroblock information */
|
|
|
|
pc->yv12_fb[pc->new_fb_idx].corrupted |= corrupt_tokens;
|
|
|
|
|
|
|
|
if (!pbi->decoded_key_frame) {
|
|
|
|
if (pc->frame_type == KEY_FRAME &&
|
|
|
|
!pc->yv12_fb[pc->new_fb_idx].corrupted)
|
|
|
|
pbi->decoded_key_frame = 1;
|
|
|
|
else
|
|
|
|
vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
|
|
|
|
"A stream must start with a complete key frame");
|
|
|
|
}
|
2010-12-16 16:46:31 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes \n",bc->pos+pbi->bc2.pos); */
|
|
|
|
vp8_adapt_coef_probs(pc);
|
|
|
|
if (pc->frame_type != KEY_FRAME) {
|
|
|
|
vp8_adapt_mode_probs(pc);
|
|
|
|
vp8_adapt_mv_probs(pc);
|
|
|
|
vp8_update_mode_context(&pbi->common);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* If this was a kf or Gf note the Q used */
|
|
|
|
if ((pc->frame_type == KEY_FRAME) ||
|
|
|
|
pc->refresh_golden_frame || pc->refresh_alt_ref_frame) {
|
|
|
|
pc->last_kf_gf_q = pc->base_qindex;
|
|
|
|
}
|
|
|
|
if (pc->refresh_entropy_probs) {
|
|
|
|
if (pc->refresh_alt_ref_frame)
|
|
|
|
vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
|
|
|
|
else
|
|
|
|
vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#ifdef PACKET_TESTING
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
FILE *f = fopen("decompressor.VP8", "ab");
|
|
|
|
unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8;
|
|
|
|
fwrite((void *) &size, 4, 1, f);
|
|
|
|
fwrite((void *) pbi->Source, size, 1, f);
|
|
|
|
fclose(f);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// printf("Frame %d Done\n", frame_count++);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|