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_BLOCKD_H_
|
|
|
|
#define VP9_COMMON_VP9_BLOCKD_H_
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
void vpx_log(const char *format, ...);
|
|
|
|
|
2012-12-23 16:20:10 +01:00
|
|
|
#include "./vpx_config.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_scale/yv12config.h"
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
#include "vp9/common/vp9_convolve.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_mv.h"
|
|
|
|
#include "vp9/common/vp9_treecoder.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_ports/mem.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#define TRUE 1
|
|
|
|
#define FALSE 0
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// #define MODE_STATS
|
2011-08-05 01:30:27 +02:00
|
|
|
|
2010-10-28 01:04:02 +02:00
|
|
|
/*#define DCPRED 1*/
|
2010-05-18 17:58:33 +02:00
|
|
|
#define DCPREDSIMTHRESH 0
|
|
|
|
#define DCPREDCNTTHRESH 3
|
|
|
|
|
|
|
|
#define MB_FEATURE_TREE_PROBS 3
|
2012-01-27 19:29:07 +01:00
|
|
|
#define PREDICTION_PROBS 3
|
2010-09-01 02:43:14 +02:00
|
|
|
|
2012-03-19 19:02:04 +01:00
|
|
|
#define MBSKIP_CONTEXTS 3
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#define MAX_MB_SEGMENTS 4
|
|
|
|
|
|
|
|
#define MAX_REF_LF_DELTAS 4
|
|
|
|
#define MAX_MODE_LF_DELTAS 4
|
|
|
|
|
2010-10-28 01:04:02 +02:00
|
|
|
/* Segment Feature Masks */
|
2010-05-18 17:58:33 +02:00
|
|
|
#define SEGMENT_DELTADATA 0
|
|
|
|
#define SEGMENT_ABSDATA 1
|
2012-11-05 13:32:49 +01:00
|
|
|
#define MAX_MV_REFS 9
|
2012-12-04 18:21:05 +01:00
|
|
|
#define MAX_MV_REF_CANDIDATES 4
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
|
|
|
int r, c;
|
2010-05-18 17:58:33 +02:00
|
|
|
} POS;
|
|
|
|
|
2013-02-20 20:36:31 +01:00
|
|
|
typedef enum {
|
2012-10-15 00:29:56 +02:00
|
|
|
PLANE_TYPE_Y_WITH_DC,
|
2013-02-15 21:09:05 +01:00
|
|
|
PLANE_TYPE_UV,
|
2012-10-15 00:29:56 +02:00
|
|
|
} PLANE_TYPE;
|
2011-02-23 22:37:08 +01:00
|
|
|
|
2010-08-31 16:49:57 +02:00
|
|
|
typedef char ENTROPY_CONTEXT;
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
|
|
|
ENTROPY_CONTEXT y1[4];
|
|
|
|
ENTROPY_CONTEXT u[2];
|
|
|
|
ENTROPY_CONTEXT v[2];
|
2010-08-31 16:49:57 +02:00
|
|
|
} ENTROPY_CONTEXT_PLANES;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-20 20:36:31 +01:00
|
|
|
#define VP9_COMBINEENTROPYCONTEXTS(Dest, A, B) \
|
2012-07-14 00:21:29 +02:00
|
|
|
Dest = ((A)!=0) + ((B)!=0);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
KEY_FRAME = 0,
|
|
|
|
INTER_FRAME = 1
|
2010-05-18 17:58:33 +02:00
|
|
|
} FRAME_TYPE;
|
|
|
|
|
2012-07-18 22:43:01 +02:00
|
|
|
typedef enum
|
|
|
|
{
|
2013-01-08 23:14:01 +01:00
|
|
|
#if CONFIG_ENABLE_6TAP
|
|
|
|
SIXTAP,
|
|
|
|
#endif
|
|
|
|
EIGHTTAP_SMOOTH,
|
|
|
|
EIGHTTAP,
|
|
|
|
EIGHTTAP_SHARP,
|
|
|
|
BILINEAR,
|
2012-07-18 22:43:01 +02:00
|
|
|
SWITCHABLE /* should be the last one */
|
|
|
|
} INTERPOLATIONFILTERTYPE;
|
|
|
|
|
|
|
|
typedef enum
|
|
|
|
{
|
2012-07-14 00:21:29 +02:00
|
|
|
DC_PRED, /* average of above and left pixels */
|
|
|
|
V_PRED, /* vertical prediction */
|
|
|
|
H_PRED, /* horizontal prediction */
|
|
|
|
D45_PRED, /* Directional 45 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
D135_PRED, /* Directional 135 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
D117_PRED, /* Directional 112 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
D153_PRED, /* Directional 157 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
D27_PRED, /* Directional 22 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
D63_PRED, /* Directional 67 deg prediction [anti-clockwise from 0 deg hor] */
|
|
|
|
TM_PRED, /* Truemotion prediction */
|
|
|
|
I8X8_PRED, /* 8x8 based prediction, each 8x8 has its own prediction mode */
|
|
|
|
B_PRED, /* block based prediction, each block has its own prediction mode */
|
|
|
|
NEARESTMV,
|
|
|
|
NEARMV,
|
|
|
|
ZEROMV,
|
|
|
|
NEWMV,
|
|
|
|
SPLITMV,
|
|
|
|
MB_MODE_COUNT
|
2010-05-18 17:58:33 +02:00
|
|
|
} MB_PREDICTION_MODE;
|
|
|
|
|
2011-09-13 12:26:39 +02:00
|
|
|
// Segment level features.
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
SEG_LVL_ALT_Q = 0, // Use alternate Quantizer ....
|
|
|
|
SEG_LVL_ALT_LF = 1, // Use alternate loop filter value...
|
|
|
|
SEG_LVL_REF_FRAME = 2, // Optional Segment reference frame
|
2013-01-28 16:22:53 +01:00
|
|
|
SEG_LVL_SKIP = 3, // Optional Segment (0,0) + skip mode
|
|
|
|
SEG_LVL_TRANSFORM = 4, // Block transform size.
|
|
|
|
SEG_LVL_MAX = 5 // Number of MB level features supported
|
2011-09-13 12:26:39 +02:00
|
|
|
} SEG_LVL_FEATURES;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2011-11-04 11:59:54 +01:00
|
|
|
// Segment level features.
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
2012-12-06 21:40:57 +01:00
|
|
|
TX_4X4 = 0, // 4x4 dct transform
|
|
|
|
TX_8X8 = 1, // 8x8 dct transform
|
|
|
|
TX_16X16 = 2, // 16x16 dct transform
|
|
|
|
TX_SIZE_MAX_MB = 3, // Number of different transforms available
|
|
|
|
TX_32X32 = TX_SIZE_MAX_MB, // 32x32 dct transform
|
|
|
|
TX_SIZE_MAX_SB, // Number of transforms available to SBs
|
2011-11-04 11:59:54 +01:00
|
|
|
} TX_SIZE;
|
|
|
|
|
2012-06-25 21:26:09 +02:00
|
|
|
typedef enum {
|
|
|
|
DCT_DCT = 0, // DCT in both horizontal and vertical
|
2012-10-22 21:19:00 +02:00
|
|
|
ADST_DCT = 1, // ADST in vertical, DCT in horizontal
|
|
|
|
DCT_ADST = 2, // DCT in vertical, ADST in horizontal
|
2012-06-25 21:26:09 +02:00
|
|
|
ADST_ADST = 3 // ADST in both directions
|
|
|
|
} TX_TYPE;
|
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
#define VP9_YMODES (B_PRED + 1)
|
|
|
|
#define VP9_UV_MODES (TM_PRED + 1)
|
|
|
|
#define VP9_I8X8_MODES (TM_PRED + 1)
|
|
|
|
#define VP9_I32X32_MODES (TM_PRED + 1)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
#define VP9_MVREFS (1 + SPLITMV - NEARESTMV)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-13 23:22:15 +01:00
|
|
|
#define WHT_UPSCALE_FACTOR 2
|
2012-11-25 04:33:58 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
B_DC_PRED, /* average of above and left pixels */
|
|
|
|
B_TM_PRED,
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-09 22:19:15 +02:00
|
|
|
B_VE_PRED, /* vertical prediction */
|
|
|
|
B_HE_PRED, /* horizontal prediction */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
B_LD_PRED,
|
|
|
|
B_RD_PRED,
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
B_VR_PRED,
|
|
|
|
B_VL_PRED,
|
|
|
|
B_HD_PRED,
|
|
|
|
B_HU_PRED,
|
2012-10-09 22:19:15 +02:00
|
|
|
#if CONFIG_NEWBINTRAMODES
|
|
|
|
B_CONTEXT_PRED,
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
LEFT4X4,
|
|
|
|
ABOVE4X4,
|
|
|
|
ZERO4X4,
|
|
|
|
NEW4X4,
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
B_MODE_COUNT
|
2010-05-18 17:58:33 +02:00
|
|
|
} B_PREDICTION_MODE;
|
|
|
|
|
2012-10-09 22:19:15 +02:00
|
|
|
#define VP9_BINTRAMODES (LEFT4X4)
|
2012-10-31 22:40:53 +01:00
|
|
|
#define VP9_SUBMVREFS (1 + NEW4X4 - LEFT4X4)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-09 22:19:15 +02:00
|
|
|
#if CONFIG_NEWBINTRAMODES
|
|
|
|
/* The number of B_PRED intra modes that are replaced by B_CONTEXT_PRED */
|
|
|
|
#define CONTEXT_PRED_REPLACEMENTS 0
|
|
|
|
#define VP9_KF_BINTRAMODES (VP9_BINTRAMODES - 1)
|
|
|
|
#define VP9_NKF_BINTRAMODES (VP9_BINTRAMODES - CONTEXT_PRED_REPLACEMENTS)
|
|
|
|
#else
|
|
|
|
#define VP9_KF_BINTRAMODES (VP9_BINTRAMODES) /* 10 */
|
|
|
|
#define VP9_NKF_BINTRAMODES (VP9_BINTRAMODES) /* 10 */
|
|
|
|
#endif
|
|
|
|
|
2012-10-22 20:25:48 +02:00
|
|
|
typedef enum {
|
|
|
|
PARTITIONING_16X8 = 0,
|
|
|
|
PARTITIONING_8X16,
|
|
|
|
PARTITIONING_8X8,
|
|
|
|
PARTITIONING_4X4,
|
|
|
|
NB_PARTITIONINGS,
|
|
|
|
} SPLITMV_PARTITIONING_TYPE;
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
/* For keyframes, intra block modes are predicted by the (already decoded)
|
|
|
|
modes for the Y blocks to the left and above us; for interframes, there
|
|
|
|
is a single probability table. */
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
union b_mode_info {
|
|
|
|
struct {
|
|
|
|
B_PREDICTION_MODE first;
|
2012-06-25 21:26:09 +02:00
|
|
|
TX_TYPE tx_type;
|
2012-10-09 22:19:15 +02:00
|
|
|
#if CONFIG_NEWBINTRAMODES
|
|
|
|
B_PREDICTION_MODE context;
|
2012-02-29 02:12:08 +01:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} as_mode;
|
2013-02-09 04:46:36 +01:00
|
|
|
int_mv as_mv[2]; // first, second inter predictor motion vectors
|
2011-05-26 21:13:00 +02:00
|
|
|
};
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
2012-11-07 15:50:25 +01:00
|
|
|
NONE = -1,
|
2012-07-14 00:21:29 +02:00
|
|
|
INTRA_FRAME = 0,
|
|
|
|
LAST_FRAME = 1,
|
|
|
|
GOLDEN_FRAME = 2,
|
|
|
|
ALTREF_FRAME = 3,
|
|
|
|
MAX_REF_FRAMES = 4
|
2010-05-18 17:58:33 +02:00
|
|
|
} MV_REFERENCE_FRAME;
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
typedef enum {
|
|
|
|
BLOCK_SIZE_MB16X16 = 0,
|
|
|
|
BLOCK_SIZE_SB32X32 = 1,
|
|
|
|
BLOCK_SIZE_SB64X64 = 2,
|
|
|
|
} BLOCK_SIZE_TYPE;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
|
|
|
MB_PREDICTION_MODE mode, uv_mode;
|
2012-11-07 15:50:25 +01:00
|
|
|
#if CONFIG_COMP_INTERINTRA_PRED
|
|
|
|
MB_PREDICTION_MODE interintra_mode, interintra_uv_mode;
|
2012-02-29 02:12:08 +01:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
MV_REFERENCE_FRAME ref_frame, second_ref_frame;
|
|
|
|
TX_SIZE txfm_size;
|
2012-08-10 01:07:41 +02:00
|
|
|
int_mv mv[2]; // for each reference frame used
|
2012-12-04 18:21:05 +01:00
|
|
|
int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
|
2012-11-09 19:52:08 +01:00
|
|
|
int_mv best_mv, best_second_mv;
|
|
|
|
#if CONFIG_NEW_MVREF
|
|
|
|
int best_index, best_second_index;
|
|
|
|
#endif
|
2012-08-24 16:44:01 +02:00
|
|
|
|
2012-11-12 16:09:25 +01:00
|
|
|
int mb_mode_context[MAX_REF_FRAMES];
|
|
|
|
|
2012-10-22 20:25:48 +02:00
|
|
|
SPLITMV_PARTITIONING_TYPE partitioning;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char mb_skip_coeff; /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
|
|
|
|
unsigned char need_to_clamp_mvs;
|
|
|
|
unsigned char need_to_clamp_secondmv;
|
|
|
|
unsigned char segment_id; /* Which set of segmentation parameters should be used for this MB */
|
|
|
|
|
|
|
|
// Flags used for prediction status of various bistream signals
|
|
|
|
unsigned char seg_id_predicted;
|
|
|
|
unsigned char ref_predicted;
|
|
|
|
|
|
|
|
// Indicates if the mb is part of the image (1) vs border (0)
|
|
|
|
// This can be useful in determining whether the MB provides
|
|
|
|
// a valid predictor
|
|
|
|
unsigned char mb_in_image;
|
2012-01-28 11:07:08 +01:00
|
|
|
|
2013-01-08 19:29:22 +01:00
|
|
|
INTERPOLATIONFILTERTYPE interp_filter;
|
2012-06-26 01:23:58 +02:00
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
BLOCK_SIZE_TYPE sb_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
} MB_MODE_INFO;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
|
|
|
MB_MODE_INFO mbmi;
|
|
|
|
union b_mode_info bmi[16];
|
2010-05-18 17:58:33 +02:00
|
|
|
} MODE_INFO;
|
|
|
|
|
2012-10-28 18:38:23 +01:00
|
|
|
typedef struct blockd {
|
2012-12-19 00:31:19 +01:00
|
|
|
int16_t *qcoeff;
|
|
|
|
int16_t *dqcoeff;
|
|
|
|
uint8_t *predictor;
|
|
|
|
int16_t *diff;
|
|
|
|
int16_t *dequant;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 16 Y blocks, 4 U blocks, 4 V blocks each with 16 entries */
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t **base_pre;
|
|
|
|
uint8_t **base_second_pre;
|
2012-07-14 00:21:29 +02:00
|
|
|
int pre;
|
|
|
|
int pre_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t **base_dst;
|
2012-07-14 00:21:29 +02:00
|
|
|
int dst;
|
|
|
|
int dst_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int eob;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
union b_mode_info bmi;
|
2010-05-18 17:58:33 +02:00
|
|
|
} BLOCKD;
|
|
|
|
|
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
|
|
|
typedef struct superblockd {
|
2013-02-15 19:15:42 +01:00
|
|
|
/* 32x32 Y and 16x16 U/V */
|
2012-12-19 00:31:19 +01:00
|
|
|
DECLARE_ALIGNED(16, int16_t, diff[32*32+16*16*2]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, qcoeff[32*32+16*16*2]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, dqcoeff[32*32+16*16*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
|
|
|
} SUPERBLOCKD;
|
|
|
|
|
2012-10-28 18:38:23 +01:00
|
|
|
typedef struct macroblockd {
|
2013-02-15 19:15:42 +01:00
|
|
|
DECLARE_ALIGNED(16, int16_t, diff[384]); /* from idct diff */
|
2012-12-19 00:31:19 +01:00
|
|
|
DECLARE_ALIGNED(16, uint8_t, predictor[384]);
|
2013-02-15 19:15:42 +01:00
|
|
|
DECLARE_ALIGNED(16, int16_t, qcoeff[384]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, dqcoeff[384]);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
SUPERBLOCKD sb_coeff_data;
|
|
|
|
|
2013-02-15 19:15:42 +01:00
|
|
|
/* 16 Y blocks, 4 U, 4 V, each with 16 entries. */
|
|
|
|
BLOCKD block[24];
|
2012-07-14 00:21:29 +02:00
|
|
|
int fullpixel_mask;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG pre; /* Filtered copy of previous frame reconstruction */
|
2013-02-07 19:09:05 +01:00
|
|
|
YV12_BUFFER_CONFIG second_pre;
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG dst;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
MODE_INFO *prev_mode_info_context;
|
|
|
|
MODE_INFO *mode_info_context;
|
|
|
|
int mode_info_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
FRAME_TYPE frame_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int up_available;
|
|
|
|
int left_available;
|
[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
|
|
|
int right_available;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-15 19:15:42 +01:00
|
|
|
/* Y,U,V */
|
2012-07-14 00:21:29 +02:00
|
|
|
ENTROPY_CONTEXT_PLANES *above_context;
|
|
|
|
ENTROPY_CONTEXT_PLANES *left_context;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 0 indicates segmentation at MB level is not enabled. Otherwise the individual bits indicate which features are active. */
|
|
|
|
unsigned char segmentation_enabled;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation map. */
|
|
|
|
unsigned char update_mb_segmentation_map;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
|
|
|
|
unsigned char update_mb_segmentation_data;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
|
|
|
|
unsigned char mb_segment_abs_delta;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Per frame flags that define which MB level features (such as quantizer or loop filter level) */
|
|
|
|
/* are enabled and when enabled the proabilities used to decode the per MB flags in MB_MODE_INFO */
|
2011-11-15 12:13:33 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Probability Tree used to code Segment number
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob mb_segment_tree_probs[MB_FEATURE_TREE_PROBS];
|
2013-01-30 18:30:46 +01:00
|
|
|
vp9_prob mb_segment_mispred_tree_probs[MAX_MB_SEGMENTS];
|
2011-11-15 12:13:33 +01:00
|
|
|
|
2012-10-25 14:58:21 +02:00
|
|
|
#if CONFIG_NEW_MVREF
|
2012-12-10 13:38:48 +01:00
|
|
|
vp9_prob mb_mv_ref_probs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES-1];
|
2012-10-25 14:58:21 +02:00
|
|
|
#endif
|
2011-09-13 12:26:39 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Segment features
|
|
|
|
signed char segment_feature_data[MAX_MB_SEGMENTS][SEG_LVL_MAX];
|
|
|
|
unsigned int segment_feature_mask[MAX_MB_SEGMENTS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* mode_based Loop filter adjustment */
|
|
|
|
unsigned char mode_ref_lf_delta_enabled;
|
|
|
|
unsigned char mode_ref_lf_delta_update;
|
|
|
|
|
|
|
|
/* Delta values have the range +/- MAX_LOOP_FILTER */
|
|
|
|
signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS]; /* 0 = Intra, Last, GF, ARF */
|
|
|
|
signed char ref_lf_deltas[MAX_REF_LF_DELTAS]; /* 0 = Intra, Last, GF, ARF */
|
|
|
|
signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS]; /* 0 = BPRED, ZERO_MV, MV, SPLIT */
|
|
|
|
signed char mode_lf_deltas[MAX_MODE_LF_DELTAS]; /* 0 = BPRED, ZERO_MV, MV, SPLIT */
|
|
|
|
|
|
|
|
/* Distance of MB away from frame edges */
|
|
|
|
int mb_to_left_edge;
|
|
|
|
int mb_to_right_edge;
|
|
|
|
int mb_to_top_edge;
|
|
|
|
int mb_to_bottom_edge;
|
|
|
|
|
|
|
|
unsigned int frames_since_golden;
|
|
|
|
unsigned int frames_till_alt_ref_frame;
|
2012-11-25 04:33:58 +01:00
|
|
|
|
2013-02-12 00:58:22 +01:00
|
|
|
int lossless;
|
2012-11-25 04:33:58 +01:00
|
|
|
/* Inverse transform function pointers. */
|
2013-02-12 06:14:46 +01:00
|
|
|
void (*inv_txm4x4_1)(int16_t *input, int16_t *output, int pitch);
|
|
|
|
void (*inv_txm4x4)(int16_t *input, int16_t *output, int pitch);
|
|
|
|
void (*itxm_add)(int16_t *input, const int16_t *dq,
|
2013-02-12 00:58:22 +01:00
|
|
|
uint8_t *pred, uint8_t *output, int pitch, int stride);
|
2013-02-12 06:14:46 +01:00
|
|
|
void (*dc_only_itxm_add)(int input_dc, uint8_t *pred_ptr,
|
2013-02-12 00:58:22 +01:00
|
|
|
uint8_t *dst_ptr, int pitch, int stride);
|
2013-02-12 06:14:46 +01:00
|
|
|
void (*itxm_add_y_block)(int16_t *q, const int16_t *dq,
|
2013-02-21 19:04:40 +01:00
|
|
|
uint8_t *pre, uint8_t *dst, int stride, struct macroblockd *xd);
|
2013-02-12 06:14:46 +01:00
|
|
|
void (*itxm_add_uv_block)(int16_t *q, const int16_t *dq,
|
2013-02-12 00:58:22 +01:00
|
|
|
uint8_t *pre, uint8_t *dst_u, uint8_t *dst_v, int stride,
|
2013-02-21 19:04:40 +01:00
|
|
|
struct macroblockd *xd);
|
2012-11-25 04:33:58 +01:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
struct subpix_fn_table subpix;
|
2012-11-25 04:33:58 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int allow_high_precision_mv;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int corrupted;
|
2010-12-16 16:46:31 +01:00
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
int sb_index;
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_index; // Index of the MB in the SB (0..3)
|
2012-06-25 21:26:09 +02:00
|
|
|
int q_index;
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
} MACROBLOCKD;
|
|
|
|
|
2013-02-05 21:37:13 +01:00
|
|
|
#define ACTIVE_HT 110 // quantization stepsize threshold
|
2012-10-16 01:41:41 +02:00
|
|
|
|
2013-02-05 21:37:13 +01:00
|
|
|
#define ACTIVE_HT8 300
|
2012-10-16 01:41:41 +02:00
|
|
|
|
2013-02-16 23:08:36 +01:00
|
|
|
#define ACTIVE_HT16 300
|
2012-10-16 01:41:41 +02:00
|
|
|
|
|
|
|
// convert MB_PREDICTION_MODE to B_PREDICTION_MODE
|
|
|
|
static B_PREDICTION_MODE pred_mode_conv(MB_PREDICTION_MODE mode) {
|
|
|
|
B_PREDICTION_MODE b_mode;
|
|
|
|
switch (mode) {
|
|
|
|
case DC_PRED:
|
|
|
|
b_mode = B_DC_PRED;
|
|
|
|
break;
|
|
|
|
case V_PRED:
|
|
|
|
b_mode = B_VE_PRED;
|
|
|
|
break;
|
|
|
|
case H_PRED:
|
|
|
|
b_mode = B_HE_PRED;
|
|
|
|
break;
|
|
|
|
case TM_PRED:
|
|
|
|
b_mode = B_TM_PRED;
|
|
|
|
break;
|
|
|
|
case D45_PRED:
|
|
|
|
b_mode = B_LD_PRED;
|
|
|
|
break;
|
|
|
|
case D135_PRED:
|
|
|
|
b_mode = B_RD_PRED;
|
|
|
|
break;
|
|
|
|
case D117_PRED:
|
|
|
|
b_mode = B_VR_PRED;
|
|
|
|
break;
|
|
|
|
case D153_PRED:
|
|
|
|
b_mode = B_HD_PRED;
|
|
|
|
break;
|
|
|
|
case D27_PRED:
|
|
|
|
b_mode = B_HU_PRED;
|
|
|
|
break;
|
|
|
|
case D63_PRED:
|
|
|
|
b_mode = B_VL_PRED;
|
|
|
|
break;
|
|
|
|
default :
|
|
|
|
// for debug purpose, to be removed after full testing
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return b_mode;
|
|
|
|
}
|
|
|
|
|
2012-08-02 18:07:33 +02:00
|
|
|
// transform mapping
|
2012-10-16 01:41:41 +02:00
|
|
|
static TX_TYPE txfm_map(B_PREDICTION_MODE bmode) {
|
2012-08-29 20:25:38 +02:00
|
|
|
// map transform type
|
2012-10-16 01:41:41 +02:00
|
|
|
TX_TYPE tx_type;
|
2012-08-02 18:07:33 +02:00
|
|
|
switch (bmode) {
|
|
|
|
case B_TM_PRED :
|
|
|
|
case B_RD_PRED :
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = ADST_ADST;
|
2012-08-02 18:07:33 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case B_VE_PRED :
|
|
|
|
case B_VR_PRED :
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = ADST_DCT;
|
2012-08-02 18:07:33 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case B_HE_PRED :
|
|
|
|
case B_HD_PRED :
|
|
|
|
case B_HU_PRED :
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = DCT_ADST;
|
2012-08-02 18:07:33 +02:00
|
|
|
break;
|
|
|
|
|
2012-10-09 22:19:15 +02:00
|
|
|
#if CONFIG_NEWBINTRAMODES
|
|
|
|
case B_CONTEXT_PRED:
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2012-08-02 18:07:33 +02:00
|
|
|
default :
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = DCT_DCT;
|
2012-08-02 18:07:33 +02:00
|
|
|
break;
|
|
|
|
}
|
2012-10-16 01:41:41 +02:00
|
|
|
return tx_type;
|
|
|
|
}
|
|
|
|
|
2013-02-15 19:15:42 +01:00
|
|
|
extern const uint8_t vp9_block2left[TX_SIZE_MAX_SB][24];
|
|
|
|
extern const uint8_t vp9_block2above[TX_SIZE_MAX_SB][24];
|
2012-12-06 21:40:57 +01:00
|
|
|
|
2012-11-16 00:14:38 +01:00
|
|
|
#define USE_ADST_FOR_I16X16_8X8 0
|
|
|
|
#define USE_ADST_FOR_I16X16_4X4 0
|
|
|
|
#define USE_ADST_FOR_I8X8_4X4 1
|
|
|
|
#define USE_ADST_PERIPHERY_ONLY 1
|
|
|
|
|
2012-10-16 01:41:41 +02:00
|
|
|
static TX_TYPE get_tx_type_4x4(const MACROBLOCKD *xd, const BLOCKD *b) {
|
2012-11-16 00:14:38 +01:00
|
|
|
// TODO(debargha): explore different patterns for ADST usage when blocksize
|
|
|
|
// is smaller than the prediction size
|
2012-10-16 01:41:41 +02:00
|
|
|
TX_TYPE tx_type = DCT_DCT;
|
2012-11-16 00:14:38 +01:00
|
|
|
int ib = (int)(b - xd->block);
|
|
|
|
if (ib >= 16)
|
|
|
|
return tx_type;
|
2013-02-12 00:58:22 +01:00
|
|
|
if (xd->lossless)
|
2013-02-12 06:14:46 +01:00
|
|
|
return DCT_DCT;
|
2012-11-16 00:14:38 +01:00
|
|
|
// TODO(rbultje, debargha): Explore ADST usage for superblocks
|
2013-01-06 03:20:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.sb_type)
|
2012-11-16 00:14:38 +01:00
|
|
|
return tx_type;
|
2012-10-16 01:41:41 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode == B_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT) {
|
2012-10-09 22:19:15 +02:00
|
|
|
tx_type = txfm_map(
|
|
|
|
#if CONFIG_NEWBINTRAMODES
|
|
|
|
b->bmi.as_mode.first == B_CONTEXT_PRED ? b->bmi.as_mode.context :
|
|
|
|
#endif
|
|
|
|
b->bmi.as_mode.first);
|
2012-11-16 00:14:38 +01:00
|
|
|
} else if (xd->mode_info_context->mbmi.mode == I8X8_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT) {
|
|
|
|
#if USE_ADST_FOR_I8X8_4X4
|
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
|
|
|
// Use ADST for periphery blocks only
|
|
|
|
int ic = (ib & 10);
|
|
|
|
b += ic - ib;
|
|
|
|
tx_type = (ic != 10) ?
|
|
|
|
txfm_map(pred_mode_conv((MB_PREDICTION_MODE)b->bmi.as_mode.first)) :
|
|
|
|
DCT_DCT;
|
|
|
|
#else
|
|
|
|
// Use ADST
|
|
|
|
tx_type = txfm_map(pred_mode_conv(
|
|
|
|
(MB_PREDICTION_MODE)b->bmi.as_mode.first));
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
// Use 2D DCT
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#endif
|
|
|
|
} else if (xd->mode_info_context->mbmi.mode < I8X8_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT) {
|
|
|
|
#if USE_ADST_FOR_I16X16_4X4
|
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
|
|
|
// Use ADST for periphery blocks only
|
|
|
|
tx_type = (ib < 4 || ((ib & 3) == 0)) ?
|
|
|
|
txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode)) : DCT_DCT;
|
|
|
|
#else
|
|
|
|
// Use ADST
|
|
|
|
tx_type = txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode));
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
// Use 2D DCT
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#endif
|
2012-10-16 01:41:41 +02:00
|
|
|
}
|
|
|
|
return tx_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static TX_TYPE get_tx_type_8x8(const MACROBLOCKD *xd, const BLOCKD *b) {
|
2012-11-16 00:14:38 +01:00
|
|
|
// TODO(debargha): explore different patterns for ADST usage when blocksize
|
|
|
|
// is smaller than the prediction size
|
2012-10-16 01:41:41 +02:00
|
|
|
TX_TYPE tx_type = DCT_DCT;
|
2012-11-16 00:14:38 +01:00
|
|
|
int ib = (int)(b - xd->block);
|
|
|
|
if (ib >= 16)
|
|
|
|
return tx_type;
|
|
|
|
// TODO(rbultje, debargha): Explore ADST usage for superblocks
|
2013-01-06 03:20:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.sb_type)
|
2012-11-16 00:14:38 +01:00
|
|
|
return tx_type;
|
2012-10-16 01:41:41 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode == I8X8_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT8) {
|
2012-11-06 03:13:04 +01:00
|
|
|
// TODO(rbultje): MB_PREDICTION_MODE / B_PREDICTION_MODE should be merged
|
|
|
|
// or the relationship otherwise modified to address this type conversion.
|
|
|
|
tx_type = txfm_map(pred_mode_conv(
|
2012-11-16 00:14:38 +01:00
|
|
|
(MB_PREDICTION_MODE)b->bmi.as_mode.first));
|
|
|
|
} else if (xd->mode_info_context->mbmi.mode < I8X8_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT8) {
|
|
|
|
#if USE_ADST_FOR_I8X8_4X4
|
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
|
|
|
// Use ADST for periphery blocks only
|
|
|
|
tx_type = (ib != 10) ?
|
|
|
|
txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode)) : DCT_DCT;
|
|
|
|
#else
|
|
|
|
// Use ADST
|
|
|
|
tx_type = txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode));
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
// Use 2D DCT
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#endif
|
2012-10-16 01:41:41 +02:00
|
|
|
}
|
|
|
|
return tx_type;
|
2012-08-02 18:07:33 +02:00
|
|
|
}
|
2012-09-21 23:20:15 +02:00
|
|
|
|
2012-10-16 01:41:41 +02:00
|
|
|
static TX_TYPE get_tx_type_16x16(const MACROBLOCKD *xd, const BLOCKD *b) {
|
|
|
|
TX_TYPE tx_type = DCT_DCT;
|
2012-11-16 00:14:38 +01:00
|
|
|
int ib = (int)(b - xd->block);
|
|
|
|
if (ib >= 16)
|
|
|
|
return tx_type;
|
|
|
|
// TODO(rbultje, debargha): Explore ADST usage for superblocks
|
2013-01-06 03:20:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.sb_type)
|
2012-11-16 00:14:38 +01:00
|
|
|
return tx_type;
|
|
|
|
if (xd->mode_info_context->mbmi.mode < I8X8_PRED &&
|
2012-10-16 01:41:41 +02:00
|
|
|
xd->q_index < ACTIVE_HT16) {
|
|
|
|
tx_type = txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode));
|
|
|
|
}
|
|
|
|
return tx_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static TX_TYPE get_tx_type(const MACROBLOCKD *xd, const BLOCKD *b) {
|
2012-09-21 23:20:15 +02:00
|
|
|
TX_TYPE tx_type = DCT_DCT;
|
2012-11-05 23:22:59 +01:00
|
|
|
int ib = (int)(b - xd->block);
|
2012-10-16 01:41:41 +02:00
|
|
|
if (ib >= 16)
|
|
|
|
return tx_type;
|
2012-09-21 23:20:15 +02:00
|
|
|
if (xd->mode_info_context->mbmi.txfm_size == TX_16X16) {
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = get_tx_type_16x16(xd, b);
|
2012-09-21 23:20:15 +02:00
|
|
|
}
|
|
|
|
if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
|
|
|
|
ib = (ib & 8) + ((ib & 4) >> 1);
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = get_tx_type_8x8(xd, &xd->block[ib]);
|
2012-09-21 23:20:15 +02:00
|
|
|
}
|
|
|
|
if (xd->mode_info_context->mbmi.txfm_size == TX_4X4) {
|
2012-10-16 01:41:41 +02:00
|
|
|
tx_type = get_tx_type_4x4(xd, b);
|
2012-09-21 23:20:15 +02:00
|
|
|
}
|
|
|
|
return tx_type;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-20 20:36:31 +01:00
|
|
|
void vp9_build_block_doffsets(MACROBLOCKD *xd);
|
|
|
|
void vp9_setup_block_dptrs(MACROBLOCKD *xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void update_blockd_bmi(MACROBLOCKD *xd) {
|
|
|
|
int i;
|
|
|
|
int is_4x4;
|
|
|
|
is_4x4 = (xd->mode_info_context->mbmi.mode == SPLITMV) ||
|
2012-09-20 21:41:59 +02:00
|
|
|
(xd->mode_info_context->mbmi.mode == I8X8_PRED) ||
|
|
|
|
(xd->mode_info_context->mbmi.mode == B_PRED);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (is_4x4) {
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
xd->block[i].bmi = xd->mode_info_context->bmi[i];
|
2011-08-05 01:30:27 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-08-05 01:30:27 +02:00
|
|
|
}
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_COMMON_VP9_BLOCKD_H_
|