2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
2012-11-30 01:36:10 +01:00
|
|
|
#ifndef VP9_COMMON_VP9_ONYXC_INT_H_
|
|
|
|
|
#define VP9_COMMON_VP9_ONYXC_INT_H_
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2010-05-24 17:39:59 +02:00
|
|
|
#include "vpx_config.h"
|
|
|
|
|
#include "vpx/internal/vpx_codec_internal.h"
|
2012-11-09 02:09:30 +01:00
|
|
|
#include "vp9_rtcd.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_loopfilter.h"
|
|
|
|
|
#include "vp9/common/vp9_entropymv.h"
|
|
|
|
|
#include "vp9/common/vp9_entropy.h"
|
|
|
|
|
#include "vp9/common/vp9_entropymode.h"
|
2013-04-30 22:39:50 +02:00
|
|
|
#include "vp9/common/vp9_quant_common.h"
|
2013-04-03 00:08:50 +02:00
|
|
|
|
2011-08-01 22:42:14 +02:00
|
|
|
#if CONFIG_POSTPROC
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_postproc.h"
|
2011-08-01 22:42:14 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2010-10-28 01:04:02 +02:00
|
|
|
/*#ifdef PACKET_TESTING*/
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_header.h"
|
2010-10-28 01:04:02 +02:00
|
|
|
/*#endif*/
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
/* Create/destroy static data structures. */
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_initialize_common(void);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-03 01:41:19 +02:00
|
|
|
// Define the number of candidate reference buffers.
|
2013-04-03 00:08:50 +02:00
|
|
|
#define NUM_REF_FRAMES 8
|
|
|
|
|
#define NUM_REF_FRAMES_LG2 3
|
2013-02-20 21:34:31 +01:00
|
|
|
|
2013-04-09 19:17:22 +02:00
|
|
|
#define ALLOWED_REFS_PER_FRAME 3
|
|
|
|
|
|
2013-02-20 21:34:31 +01:00
|
|
|
// 1 scratch frame for the new frame, 3 for scaled references on the encoder
|
|
|
|
|
// TODO(jkoleszar): These 3 extra references could probably come from the
|
|
|
|
|
// normal reference pool.
|
|
|
|
|
#define NUM_YV12_BUFFERS (NUM_REF_FRAMES + 4)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-01-16 00:57:11 +01:00
|
|
|
#define NUM_FRAME_CONTEXTS_LG2 2
|
|
|
|
|
#define NUM_FRAME_CONTEXTS (1 << NUM_FRAME_CONTEXTS_LG2)
|
|
|
|
|
|
2012-02-29 02:25:45 +01:00
|
|
|
#define COMP_PRED_CONTEXTS 2
|
2012-02-09 16:44:18 +01:00
|
|
|
|
2013-04-03 00:08:50 +02:00
|
|
|
#define MAX_LAG_BUFFERS 25
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct frame_contexts {
|
2012-10-09 22:19:15 +02:00
|
|
|
vp9_prob bmode_prob[VP9_NKF_BINTRAMODES - 1];
|
|
|
|
|
vp9_prob ymode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
|
2012-11-16 00:50:07 +01:00
|
|
|
vp9_prob sb_ymode_prob[VP9_I32X32_MODES - 1];
|
2012-10-09 22:19:15 +02:00
|
|
|
vp9_prob uv_mode_prob[VP9_YMODES][VP9_UV_MODES - 1];
|
|
|
|
|
vp9_prob sub_mv_ref_prob[SUBMVREF_COUNT][VP9_SUBMVREFS - 1];
|
2013-04-23 19:12:18 +02:00
|
|
|
vp9_prob partition_prob[NUM_PARTITION_CONTEXTS][PARTITION_TYPES - 1];
|
2013-02-20 19:16:24 +01:00
|
|
|
|
2013-02-19 22:36:38 +01:00
|
|
|
vp9_coeff_probs coef_probs_4x4[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_probs coef_probs_8x8[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_probs coef_probs_16x16[BLOCK_TYPES];
|
2013-03-04 23:12:17 +01:00
|
|
|
vp9_coeff_probs coef_probs_32x32[BLOCK_TYPES];
|
2012-09-10 07:42:35 +02:00
|
|
|
|
2012-07-26 22:42:07 +02:00
|
|
|
nmv_context nmvc;
|
|
|
|
|
nmv_context pre_nmvc;
|
2012-10-09 22:19:15 +02:00
|
|
|
vp9_prob pre_bmode_prob[VP9_NKF_BINTRAMODES - 1];
|
|
|
|
|
vp9_prob pre_ymode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
|
2012-11-16 00:50:07 +01:00
|
|
|
vp9_prob pre_sb_ymode_prob[VP9_I32X32_MODES - 1];
|
2012-10-09 22:19:15 +02:00
|
|
|
vp9_prob pre_uv_mode_prob[VP9_YMODES][VP9_UV_MODES - 1];
|
|
|
|
|
vp9_prob pre_sub_mv_ref_prob[SUBMVREF_COUNT][VP9_SUBMVREFS - 1];
|
2013-04-23 19:12:18 +02:00
|
|
|
vp9_prob pre_partition_prob[NUM_PARTITION_CONTEXTS][PARTITION_TYPES - 1];
|
2012-10-09 22:19:15 +02:00
|
|
|
unsigned int bmode_counts[VP9_NKF_BINTRAMODES];
|
|
|
|
|
unsigned int ymode_counts[VP9_YMODES]; /* interframe intra mode probs */
|
2012-11-16 00:50:07 +01:00
|
|
|
unsigned int sb_ymode_counts[VP9_I32X32_MODES];
|
2012-10-09 22:19:15 +02:00
|
|
|
unsigned int uv_mode_counts[VP9_YMODES][VP9_UV_MODES];
|
|
|
|
|
unsigned int sub_mv_ref_counts[SUBMVREF_COUNT][VP9_SUBMVREFS];
|
2013-04-23 19:12:18 +02:00
|
|
|
unsigned int partition_counts[NUM_PARTITION_CONTEXTS][PARTITION_TYPES];
|
2012-10-31 22:40:53 +01:00
|
|
|
|
2013-02-19 22:36:38 +01:00
|
|
|
vp9_coeff_probs pre_coef_probs_4x4[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_probs pre_coef_probs_8x8[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_probs pre_coef_probs_16x16[BLOCK_TYPES];
|
2013-03-04 23:12:17 +01:00
|
|
|
vp9_coeff_probs pre_coef_probs_32x32[BLOCK_TYPES];
|
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-07 23:45:05 +01:00
|
|
|
|
2013-02-19 22:36:38 +01:00
|
|
|
vp9_coeff_count coef_counts_4x4[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_count coef_counts_8x8[BLOCK_TYPES];
|
|
|
|
|
vp9_coeff_count coef_counts_16x16[BLOCK_TYPES];
|
2013-03-04 23:12:17 +01:00
|
|
|
vp9_coeff_count coef_counts_32x32[BLOCK_TYPES];
|
2013-03-27 00:46:09 +01:00
|
|
|
unsigned int eob_branch_counts[TX_SIZE_MAX_SB][BLOCK_TYPES][REF_TYPES]
|
|
|
|
|
[COEF_BANDS][PREV_COEF_CONTEXTS];
|
|
|
|
|
|
2012-07-26 22:42:07 +02:00
|
|
|
nmv_context_counts NMVcount;
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob switchable_interp_prob[VP9_SWITCHABLE_FILTERS + 1]
|
|
|
|
|
[VP9_SWITCHABLE_FILTERS - 1];
|
2012-07-18 22:43:01 +02:00
|
|
|
|
2012-11-12 16:09:25 +01:00
|
|
|
int vp9_mode_contexts[INTER_MODE_CONTEXTS][4];
|
2012-11-29 17:13:18 +01:00
|
|
|
unsigned int mv_ref_ct[INTER_MODE_CONTEXTS][4][2];
|
2010-05-18 17:58:33 +02:00
|
|
|
} FRAME_CONTEXT;
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
|
RECON_CLAMP_REQUIRED = 0,
|
|
|
|
|
RECON_CLAMP_NOTREQUIRED = 1
|
2010-05-18 17:58:33 +02:00
|
|
|
} CLAMP_TYPE;
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
|
SINGLE_PREDICTION_ONLY = 0,
|
|
|
|
|
COMP_PREDICTION_ONLY = 1,
|
|
|
|
|
HYBRID_PREDICTION = 2,
|
|
|
|
|
NB_PREDICTION_TYPES = 3,
|
2012-02-29 02:25:45 +01:00
|
|
|
} COMPPREDMODE_TYPE;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
|
ONLY_4X4 = 0,
|
2012-10-09 18:18:21 +02:00
|
|
|
ALLOW_8X8 = 1,
|
|
|
|
|
ALLOW_16X16 = 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-07 23:45:05 +01:00
|
|
|
ALLOW_32X32 = 3,
|
2013-01-10 17:23:59 +01:00
|
|
|
TX_MODE_SELECT = 4,
|
|
|
|
|
NB_TXFM_MODES = 5,
|
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
|
|
|
} TXFM_MODE;
|
|
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
typedef struct VP9Common {
|
2012-07-14 00:21:29 +02:00
|
|
|
struct vpx_internal_error_info error;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-01 22:25:10 +02:00
|
|
|
DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][2]);
|
|
|
|
|
DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][2]);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-03-21 00:41:30 +01:00
|
|
|
int width;
|
|
|
|
|
int height;
|
2013-03-14 22:36:08 +01:00
|
|
|
int display_width;
|
|
|
|
|
int display_height;
|
2013-02-20 21:34:31 +01:00
|
|
|
int last_width;
|
|
|
|
|
int last_height;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-07 00:52:06 +02:00
|
|
|
// TODO(jkoleszar): this implies chroma ss right now, but could vary per
|
|
|
|
|
// plane. Revisit as part of the future change to YV12_BUFFER_CONFIG to
|
|
|
|
|
// support additional planes.
|
|
|
|
|
int subsampling_x;
|
|
|
|
|
int subsampling_y;
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YUV_TYPE clr_type;
|
|
|
|
|
CLAMP_TYPE clamp_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG *frame_to_show;
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG yv12_fb[NUM_YV12_BUFFERS];
|
2013-01-15 22:49:44 +01:00
|
|
|
int fb_idx_ref_cnt[NUM_YV12_BUFFERS]; /* reference counts */
|
2013-01-16 21:19:42 +01:00
|
|
|
int ref_frame_map[NUM_REF_FRAMES]; /* maps fb_idx to reference slot */
|
|
|
|
|
|
2013-04-25 02:20:53 +02:00
|
|
|
// TODO(jkoleszar): could expand active_ref_idx to 4, with 0 as intra, and
|
|
|
|
|
// roll new_fb_idx into it.
|
|
|
|
|
|
|
|
|
|
// Each frame can reference ALLOWED_REFS_PER_FRAME buffers
|
|
|
|
|
int active_ref_idx[ALLOWED_REFS_PER_FRAME];
|
|
|
|
|
struct scale_factors active_ref_scale[ALLOWED_REFS_PER_FRAME];
|
2013-01-15 22:49:44 +01:00
|
|
|
int new_fb_idx;
|
2013-04-25 02:20:53 +02:00
|
|
|
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG post_proc_buffer;
|
|
|
|
|
YV12_BUFFER_CONFIG temp_scale_frame;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
FRAME_TYPE last_frame_type; /* Save last frame's frame type for motion search. */
|
|
|
|
|
FRAME_TYPE frame_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int show_frame;
|
2013-04-19 22:32:15 +02:00
|
|
|
int last_show_frame;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int frame_flags;
|
2013-04-26 20:57:17 +02:00
|
|
|
// MBs, mb_rows/cols is in 16-pixel units; mi_rows/cols is in
|
2013-05-05 07:09:43 +02:00
|
|
|
// MODE_INFO (8-pixel) units.
|
2012-07-14 00:21:29 +02:00
|
|
|
int MBs;
|
2013-04-26 20:57:17 +02:00
|
|
|
int mb_rows, mi_rows;
|
|
|
|
|
int mb_cols, mi_cols;
|
2012-07-14 00:21:29 +02:00
|
|
|
int mode_info_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* profile settings */
|
|
|
|
|
int experimental;
|
|
|
|
|
TXFM_MODE txfm_mode;
|
|
|
|
|
COMPPREDMODE_TYPE comp_pred_mode;
|
|
|
|
|
int no_lpf;
|
|
|
|
|
int use_bilinear_mc_filter;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int base_qindex;
|
|
|
|
|
int last_kf_gf_q; /* Q used on the last GF or KF */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-17 00:05:52 +02:00
|
|
|
int y_dc_delta_q;
|
|
|
|
|
int uv_dc_delta_q;
|
|
|
|
|
int uv_ac_delta_q;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int frames_since_golden;
|
|
|
|
|
unsigned int frames_till_alt_ref_frame;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* We allocate a MODE_INFO struct for each macroblock, together with
|
|
|
|
|
an extra row on top and column on the left to simplify prediction. */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
MODE_INFO *mip; /* Base of allocated array */
|
|
|
|
|
MODE_INFO *mi; /* Corresponds to upper left visible macroblock */
|
|
|
|
|
MODE_INFO *prev_mip; /* MODE_INFO array 'mip' from last decoded frame */
|
|
|
|
|
MODE_INFO *prev_mi; /* 'mi' from last frame (points into prev_mip) */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Persistent mb segment id map used in prediction.
|
|
|
|
|
unsigned char *last_frame_seg_map;
|
2012-01-27 19:29:07 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
INTERPOLATIONFILTERTYPE mcomp_filter_type;
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
loop_filter_info_n lf_info;
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int filter_level;
|
|
|
|
|
int last_sharpness_level;
|
|
|
|
|
int sharpness_level;
|
2013-03-20 18:22:20 +01:00
|
|
|
int dering_enabled;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-26 23:39:58 +02:00
|
|
|
int refresh_frame_context; /* Two state 0 = NO, 1 = YES */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int ref_frame_sign_bias[MAX_REF_FRAMES]; /* Two state 0, 1 */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-15 19:15:42 +01:00
|
|
|
/* Y,U,V */
|
2013-04-29 19:37:25 +02:00
|
|
|
ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
|
|
|
|
|
ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-23 19:12:18 +02:00
|
|
|
// partition contexts
|
|
|
|
|
PARTITION_CONTEXT *above_seg_context;
|
2013-05-08 00:36:30 +02:00
|
|
|
PARTITION_CONTEXT left_seg_context[8];
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* keyframe block modes are predicted by their above, left neighbors */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-09 22:19:15 +02:00
|
|
|
vp9_prob kf_bmode_prob[VP9_KF_BINTRAMODES]
|
|
|
|
|
[VP9_KF_BINTRAMODES]
|
|
|
|
|
[VP9_KF_BINTRAMODES - 1];
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob kf_ymode_prob[8][VP9_YMODES - 1]; /* keyframe "" */
|
|
|
|
|
vp9_prob sb_kf_ymode_prob[8][VP9_I32X32_MODES - 1];
|
2012-07-14 00:21:29 +02:00
|
|
|
int kf_ymode_probs_index;
|
|
|
|
|
int kf_ymode_probs_update;
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob kf_uv_mode_prob[VP9_YMODES] [VP9_UV_MODES - 1];
|
2012-01-27 19:35:14 +01:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob prob_intra_coded;
|
|
|
|
|
vp9_prob prob_last_coded;
|
|
|
|
|
vp9_prob prob_gf_coded;
|
2012-01-27 19:35:14 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Context probabilities when using predictive coding of segment id
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob segment_pred_probs[PREDICTION_PROBS];
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char temporal_update;
|
2012-01-27 19:29:07 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Context probabilities for reference frame prediction
|
|
|
|
|
unsigned char ref_scores[MAX_REF_FRAMES];
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob ref_pred_probs[PREDICTION_PROBS];
|
|
|
|
|
vp9_prob mod_refprobs[MAX_REF_FRAMES][PREDICTION_PROBS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob prob_comppred[COMP_PRED_CONTEXTS];
|
2012-02-02 15:33:34 +01:00
|
|
|
|
2012-10-09 18:18:21 +02:00
|
|
|
// FIXME contextualize
|
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-07 23:45:05 +01:00
|
|
|
vp9_prob prob_tx[TX_SIZE_MAX_SB - 1];
|
2012-10-09 18:18:21 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob mbskip_pred_probs[MBSKIP_CONTEXTS];
|
2012-03-19 19:02:04 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
FRAME_CONTEXT fc; /* this frame entropy */
|
2013-01-16 00:57:11 +01:00
|
|
|
FRAME_CONTEXT frame_contexts[NUM_FRAME_CONTEXTS];
|
|
|
|
|
unsigned int frame_context_idx; /* Context to use/update */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int current_video_frame;
|
|
|
|
|
int near_boffset[3];
|
|
|
|
|
int version;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
#ifdef PACKET_TESTING
|
2012-10-31 22:40:53 +01:00
|
|
|
VP9_HEADER oh;
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
double bitrate;
|
|
|
|
|
double framerate;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2011-08-01 22:42:14 +02:00
|
|
|
#if CONFIG_POSTPROC
|
2012-07-14 00:21:29 +02:00
|
|
|
struct postproc_state postproc_state;
|
2011-08-01 22:42:14 +02:00
|
|
|
#endif
|
2012-06-26 01:23:58 +02:00
|
|
|
|
2013-01-15 15:43:35 +01:00
|
|
|
int error_resilient_mode;
|
2013-01-25 20:30:28 +01:00
|
|
|
int frame_parallel_decoding_mode;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
|
2013-02-07 00:30:21 +01:00
|
|
|
int tile_columns, log2_tile_columns;
|
2013-04-26 20:57:17 +02:00
|
|
|
int cur_tile_mi_col_start, cur_tile_mi_col_end, cur_tile_col_idx;
|
2013-02-08 20:33:11 +01:00
|
|
|
int tile_rows, log2_tile_rows;
|
2013-04-26 20:57:17 +02:00
|
|
|
int cur_tile_mi_row_start, cur_tile_mi_row_end, cur_tile_row_idx;
|
2012-10-31 01:53:32 +01:00
|
|
|
} VP9_COMMON;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-01-15 00:52:20 +01:00
|
|
|
static int get_free_fb(VP9_COMMON *cm) {
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < NUM_YV12_BUFFERS; i++)
|
|
|
|
|
if (cm->fb_idx_ref_cnt[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
assert(i < NUM_YV12_BUFFERS);
|
|
|
|
|
cm->fb_idx_ref_cnt[i] = 1;
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void ref_cnt_fb(int *buf, int *idx, int new_idx) {
|
|
|
|
|
if (buf[*idx] > 0)
|
|
|
|
|
buf[*idx]--;
|
|
|
|
|
|
|
|
|
|
*idx = new_idx;
|
|
|
|
|
|
|
|
|
|
buf[new_idx]++;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-08 00:36:30 +02:00
|
|
|
static int mi_cols_aligned_to_sb(VP9_COMMON *cm) {
|
|
|
|
|
return 2 * ((cm->mb_cols + 3) & ~3);
|
2013-04-23 19:12:18 +02:00
|
|
|
}
|
|
|
|
|
|
2013-05-12 00:19:56 +02:00
|
|
|
static INLINE void set_partition_seg_context(VP9_COMMON *cm,
|
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
|
int mi_row, int mi_col) {
|
|
|
|
|
xd->above_seg_context = cm->above_seg_context + mi_col;
|
|
|
|
|
xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static void set_mi_row_col(VP9_COMMON *cm, MACROBLOCKD *xd,
|
|
|
|
|
int mi_row, int bh,
|
|
|
|
|
int mi_col, int bw) {
|
|
|
|
|
xd->mb_to_top_edge = -((mi_row * MI_SIZE) << 3);
|
|
|
|
|
xd->mb_to_bottom_edge = ((cm->mi_rows - bh - mi_row) * MI_SIZE) << 3;
|
|
|
|
|
xd->mb_to_left_edge = -((mi_col * MI_SIZE) << 3);
|
|
|
|
|
xd->mb_to_right_edge = ((cm->mi_cols - bw - mi_col) * MI_SIZE) << 3;
|
2013-02-20 19:16:24 +01:00
|
|
|
|
|
|
|
|
// Are edges available for intra prediction?
|
2013-04-26 20:57:17 +02:00
|
|
|
xd->up_available = (mi_row != 0);
|
|
|
|
|
xd->left_available = (mi_col > cm->cur_tile_mi_col_start);
|
|
|
|
|
xd->right_available = (mi_col + bw < cm->cur_tile_mi_col_end);
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static int get_mi_row(const MACROBLOCKD *xd) {
|
|
|
|
|
return ((-xd->mb_to_top_edge) >> (3 + LOG2_MI_SIZE));
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static int get_mi_col(const MACROBLOCKD *xd) {
|
|
|
|
|
return ((-xd->mb_to_left_edge) >> (3 + LOG2_MI_SIZE));
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
2013-03-28 18:42:23 +01:00
|
|
|
|
|
|
|
|
static int get_token_alloc(int mb_rows, int mb_cols) {
|
2013-05-09 01:15:54 +02:00
|
|
|
return mb_rows * mb_cols * (48 * 16 + 4);
|
2013-03-28 18:42:23 +01:00
|
|
|
}
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_COMMON_VP9_ONYXC_INT_H_
|