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
|
|
|
|
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"
|
2013-04-10 06:28:27 +02:00
|
|
|
#include "vp9/common/vp9_enums.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// #define MODE_STATS
|
2011-08-05 01:30:27 +02:00
|
|
|
|
2013-04-24 14:04:45 +02:00
|
|
|
#define MAX_MB_SEGMENTS 8
|
|
|
|
#define MB_SEG_TREE_PROBS (MAX_MB_SEGMENTS-1)
|
2012-01-27 19:29:07 +01:00
|
|
|
#define PREDICTION_PROBS 3
|
2010-09-01 02:43:14 +02:00
|
|
|
|
2013-04-17 20:45:35 +02:00
|
|
|
#define DEFAULT_PRED_PROB_0 120
|
|
|
|
#define DEFAULT_PRED_PROB_1 80
|
|
|
|
#define DEFAULT_PRED_PROB_2 40
|
|
|
|
|
2012-03-19 19:02:04 +01:00
|
|
|
#define MBSKIP_CONTEXTS 3
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#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
|
2013-04-19 16:40:36 +02:00
|
|
|
#define MAX_MV_REF_CANDIDATES 2
|
2010-05-18 17:58:33 +02:00
|
|
|
|
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;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-23 19:12:18 +02:00
|
|
|
typedef char PARTITION_CONTEXT;
|
|
|
|
|
2013-04-17 00:30:28 +02:00
|
|
|
static INLINE int combine_entropy_contexts(ENTROPY_CONTEXT a,
|
|
|
|
ENTROPY_CONTEXT b) {
|
|
|
|
return (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;
|
|
|
|
|
2013-02-27 20:17:38 +01:00
|
|
|
typedef enum {
|
2013-01-08 23:14:01 +01:00
|
|
|
EIGHTTAP_SMOOTH,
|
|
|
|
EIGHTTAP,
|
|
|
|
EIGHTTAP_SHARP,
|
|
|
|
BILINEAR,
|
2012-07-18 22:43:01 +02:00
|
|
|
SWITCHABLE /* should be the last one */
|
|
|
|
} INTERPOLATIONFILTERTYPE;
|
|
|
|
|
2013-02-27 20:17:38 +01:00
|
|
|
typedef enum {
|
2013-05-09 20:37:51 +02:00
|
|
|
DC_PRED, // Average of above and left pixels
|
|
|
|
V_PRED, // Vertical
|
|
|
|
H_PRED, // Horizontal
|
|
|
|
D45_PRED, // Directional 45 deg = round(arctan(1/1) * 180/pi)
|
|
|
|
D135_PRED, // Directional 135 deg = 180 - 45
|
|
|
|
D117_PRED, // Directional 117 deg = 180 - 63
|
|
|
|
D153_PRED, // Directional 153 deg = 180 - 27
|
|
|
|
D27_PRED, // Directional 27 deg = round(arctan(1/2) * 180/pi)
|
|
|
|
D63_PRED, // Directional 63 deg = round(arctan(2/1) * 180/pi)
|
|
|
|
TM_PRED, // True-motion
|
|
|
|
I4X4_PRED, // Each 4x4 subblock has its own mode
|
2012-07-14 00:21:29 +02:00
|
|
|
NEARESTMV,
|
|
|
|
NEARMV,
|
|
|
|
ZEROMV,
|
|
|
|
NEWMV,
|
|
|
|
SPLITMV,
|
|
|
|
MB_MODE_COUNT
|
2010-05-18 17:58:33 +02:00
|
|
|
} MB_PREDICTION_MODE;
|
|
|
|
|
2013-04-24 21:14:58 +02:00
|
|
|
static INLINE int is_inter_mode(MB_PREDICTION_MODE mode) {
|
|
|
|
return mode >= NEARESTMV && mode <= SPLITMV;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
2013-03-19 03:53:02 +01:00
|
|
|
SEG_LVL_MAX = 4 // 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;
|
|
|
|
|
2013-04-11 21:16:35 +02:00
|
|
|
#define VP9_YMODES (I4X4_PRED + 1)
|
2012-10-31 22:40:53 +01:00
|
|
|
#define VP9_UV_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 */
|
2013-04-12 00:52:28 +02:00
|
|
|
B_V_PRED, /* vertical prediction */
|
|
|
|
B_H_PRED, /* horizontal prediction */
|
|
|
|
B_D45_PRED,
|
|
|
|
B_D135_PRED,
|
|
|
|
B_D117_PRED,
|
|
|
|
B_D153_PRED,
|
|
|
|
B_D27_PRED,
|
|
|
|
B_D63_PRED,
|
2012-07-14 00:21:29 +02:00
|
|
|
B_TM_PRED,
|
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
|
|
|
#define VP9_KF_BINTRAMODES (VP9_BINTRAMODES) /* 10 */
|
|
|
|
#define VP9_NKF_BINTRAMODES (VP9_BINTRAMODES) /* 10 */
|
|
|
|
|
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;
|
|
|
|
} 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-04-29 21:43:38 +02:00
|
|
|
static INLINE int b_width_log2(BLOCK_SIZE_TYPE sb_type) {
|
2013-04-10 06:28:27 +02:00
|
|
|
switch (sb_type) {
|
2013-05-07 19:45:31 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
case BLOCK_SIZE_SB4X8:
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_AB4X4: return 0;
|
2013-05-07 19:45:31 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
case BLOCK_SIZE_SB8X4:
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB8X8:
|
|
|
|
case BLOCK_SIZE_SB8X16: return 1;
|
2013-04-26 20:57:17 +02:00
|
|
|
case BLOCK_SIZE_SB16X8:
|
2013-04-25 00:10:23 +02:00
|
|
|
case BLOCK_SIZE_MB16X16:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB16X32: return 2;
|
2013-04-10 06:28:27 +02:00
|
|
|
case BLOCK_SIZE_SB32X16:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
case BLOCK_SIZE_SB32X64: return 3;
|
2013-04-10 06:28:27 +02:00
|
|
|
case BLOCK_SIZE_SB64X32:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB64X64: return 4;
|
2013-04-10 06:28:27 +02:00
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-29 21:43:38 +02:00
|
|
|
static INLINE int b_height_log2(BLOCK_SIZE_TYPE sb_type) {
|
2013-04-10 06:28:27 +02:00
|
|
|
switch (sb_type) {
|
2013-05-07 19:45:31 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
case BLOCK_SIZE_SB8X4:
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_AB4X4: return 0;
|
2013-05-07 19:45:31 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
case BLOCK_SIZE_SB4X8:
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB8X8:
|
|
|
|
case BLOCK_SIZE_SB16X8: return 1;
|
2013-04-26 20:57:17 +02:00
|
|
|
case BLOCK_SIZE_SB8X16:
|
2013-04-25 00:10:23 +02:00
|
|
|
case BLOCK_SIZE_MB16X16:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB32X16: return 2;
|
2013-04-10 06:28:27 +02:00
|
|
|
case BLOCK_SIZE_SB16X32:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
case BLOCK_SIZE_SB64X32: return 3;
|
2013-04-10 06:28:27 +02:00
|
|
|
case BLOCK_SIZE_SB32X64:
|
2013-04-29 21:43:38 +02:00
|
|
|
case BLOCK_SIZE_SB64X64: return 4;
|
2013-04-10 06:28:27 +02:00
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-04-29 21:43:38 +02:00
|
|
|
static INLINE int mi_width_log2(BLOCK_SIZE_TYPE sb_type) {
|
|
|
|
int a = b_width_log2(sb_type) - 1;
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
// align 4x4 block to mode_info
|
|
|
|
if (a < 0)
|
|
|
|
a = 0;
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
assert(a >= 0);
|
|
|
|
return a;
|
2013-04-11 21:12:11 +02:00
|
|
|
}
|
|
|
|
|
2013-04-29 21:43:38 +02:00
|
|
|
static INLINE int mi_height_log2(BLOCK_SIZE_TYPE sb_type) {
|
|
|
|
int a = b_height_log2(sb_type) - 1;
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
if (a < 0)
|
|
|
|
a = 0;
|
|
|
|
#endif
|
2013-04-29 21:43:38 +02:00
|
|
|
assert(a >= 0);
|
|
|
|
return a;
|
2013-04-11 21:12:11 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
|
|
|
MB_PREDICTION_MODE mode, uv_mode;
|
|
|
|
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;
|
2012-08-24 16:44:01 +02:00
|
|
|
|
2012-11-12 16:09:25 +01:00
|
|
|
int mb_mode_context[MAX_REF_FRAMES];
|
|
|
|
|
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;
|
2013-04-23 15:01:55 +02:00
|
|
|
unsigned char segment_id; // Segment id for current frame
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// 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;
|
2013-05-05 07:09:43 +02:00
|
|
|
union b_mode_info bmi[4];
|
2010-05-18 17:58:33 +02:00
|
|
|
} MODE_INFO;
|
|
|
|
|
2013-02-09 02:49:44 +01:00
|
|
|
struct scale_factors {
|
|
|
|
int x_num;
|
|
|
|
int x_den;
|
|
|
|
int x_offset_q4;
|
Spatial resamping of ZEROMV predictors
This patch allows coding frames using references of different
resolution, in ZEROMV mode. For compound prediction, either
reference may be scaled.
To test, I use the resize_test and enable WRITE_RECON_BUFFER
in vp9_onyxd_if.c. It's also useful to apply this patch to
test/i420_video_source.h:
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -93,6 +93,7 @@ class I420VideoSource : public VideoSource {
virtual void FillFrame() {
// Read a frame from input_file.
+ if (frame_ != 3)
if (fread(img_->img_data, raw_sz_, 1, input_file_) == 0) {
limit_ = frame_;
}
This forces the frame that the resolution changes on to be coded
with no motion, only scaling, and improves the quality of the
result.
Change-Id: I1ee75d19a437ff801192f767fd02a36bcbd1d496
2013-02-25 05:55:14 +01:00
|
|
|
int x_step_q4;
|
2013-02-09 02:49:44 +01:00
|
|
|
int y_num;
|
|
|
|
int y_den;
|
|
|
|
int y_offset_q4;
|
Spatial resamping of ZEROMV predictors
This patch allows coding frames using references of different
resolution, in ZEROMV mode. For compound prediction, either
reference may be scaled.
To test, I use the resize_test and enable WRITE_RECON_BUFFER
in vp9_onyxd_if.c. It's also useful to apply this patch to
test/i420_video_source.h:
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -93,6 +93,7 @@ class I420VideoSource : public VideoSource {
virtual void FillFrame() {
// Read a frame from input_file.
+ if (frame_ != 3)
if (fread(img_->img_data, raw_sz_, 1, input_file_) == 0) {
limit_ = frame_;
}
This forces the frame that the resolution changes on to be coded
with no motion, only scaling, and improves the quality of the
result.
Change-Id: I1ee75d19a437ff801192f767fd02a36bcbd1d496
2013-02-25 05:55:14 +01:00
|
|
|
int y_step_q4;
|
2013-04-04 18:56:02 +02:00
|
|
|
|
|
|
|
int (*scale_value_x)(int val, const struct scale_factors *scale);
|
|
|
|
int (*scale_value_y)(int val, const struct scale_factors *scale);
|
|
|
|
void (*set_scaled_offsets)(struct scale_factors *scale, int row, int col);
|
|
|
|
int_mv32 (*scale_motion_vector_q3_to_q4)(const int_mv *src_mv,
|
|
|
|
const struct scale_factors *scale);
|
|
|
|
int32_t (*scale_motion_vector_component_q4)(int mv_q4,
|
|
|
|
int num,
|
|
|
|
int den,
|
|
|
|
int offset_q4);
|
|
|
|
|
Spatial resamping of ZEROMV predictors
This patch allows coding frames using references of different
resolution, in ZEROMV mode. For compound prediction, either
reference may be scaled.
To test, I use the resize_test and enable WRITE_RECON_BUFFER
in vp9_onyxd_if.c. It's also useful to apply this patch to
test/i420_video_source.h:
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -93,6 +93,7 @@ class I420VideoSource : public VideoSource {
virtual void FillFrame() {
// Read a frame from input_file.
+ if (frame_ != 3)
if (fread(img_->img_data, raw_sz_, 1, input_file_) == 0) {
limit_ = frame_;
}
This forces the frame that the resolution changes on to be coded
with no motion, only scaling, and improves the quality of the
result.
Change-Id: I1ee75d19a437ff801192f767fd02a36bcbd1d496
2013-02-25 05:55:14 +01:00
|
|
|
convolve_fn_t predict[2][2][2]; // horiz, vert, avg
|
2013-02-09 02:49:44 +01:00
|
|
|
};
|
|
|
|
|
2013-04-02 23:50:40 +02:00
|
|
|
enum { MAX_MB_PLANE = 3 };
|
|
|
|
|
2013-04-20 00:52:17 +02:00
|
|
|
struct buf_2d {
|
|
|
|
uint8_t *buf;
|
|
|
|
int stride;
|
|
|
|
};
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
struct macroblockd_plane {
|
2013-04-02 23:50:40 +02:00
|
|
|
DECLARE_ALIGNED(16, int16_t, qcoeff[64 * 64]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, dqcoeff[64 * 64]);
|
2013-04-04 21:03:27 +02:00
|
|
|
DECLARE_ALIGNED(16, uint16_t, eobs[256]);
|
2013-04-19 20:07:47 +02:00
|
|
|
DECLARE_ALIGNED(16, int16_t, diff[64 * 64]);
|
2013-04-06 00:54:59 +02:00
|
|
|
PLANE_TYPE plane_type;
|
|
|
|
int subsampling_x;
|
|
|
|
int subsampling_y;
|
2013-04-20 00:52:17 +02:00
|
|
|
struct buf_2d dst;
|
|
|
|
struct buf_2d pre[2];
|
2013-04-24 23:48:17 +02:00
|
|
|
int16_t *dequant;
|
2013-04-29 19:37:25 +02:00
|
|
|
ENTROPY_CONTEXT *above_context;
|
|
|
|
ENTROPY_CONTEXT *left_context;
|
2013-04-02 23:50:40 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#define BLOCK_OFFSET(x, i, n) ((x) + (i) * (n))
|
|
|
|
|
2012-10-28 18:38:23 +01:00
|
|
|
typedef struct macroblockd {
|
2013-04-23 17:26:10 +02:00
|
|
|
struct macroblockd_plane plane[MAX_MB_PLANE];
|
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-09 02:49:44 +01:00
|
|
|
struct scale_factors scale_factor[2];
|
|
|
|
struct scale_factors scale_factor_uv[2];
|
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-04-23 19:12:18 +02:00
|
|
|
// partition contexts
|
|
|
|
PARTITION_CONTEXT *above_seg_context;
|
|
|
|
PARTITION_CONTEXT *left_seg_context;
|
|
|
|
|
2013-04-30 01:07:17 +02:00
|
|
|
/* 0 (disable) 1 (enable) segmentation */
|
2012-07-14 00:21:29 +02:00
|
|
|
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
|
|
|
|
2013-04-23 15:01:55 +02:00
|
|
|
#if CONFIG_IMPLICIT_SEGMENTATION
|
|
|
|
unsigned char allow_implicit_segment_update;
|
|
|
|
#endif
|
|
|
|
|
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
|
2013-04-24 14:04:45 +02:00
|
|
|
vp9_prob mb_segment_tree_probs[MB_SEG_TREE_PROBS];
|
2011-11-15 12:13:33 +01: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 */
|
2013-04-11 21:16:35 +02:00
|
|
|
/* 0 = Intra, Last, GF, ARF */
|
|
|
|
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 = I4X4_PRED, ZERO_MV, MV, SPLIT */
|
|
|
|
signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
|
|
|
|
/* 0 = I4X4_PRED, ZERO_MV, MV, SPLIT */
|
|
|
|
signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/* 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);
|
2013-04-22 23:53:07 +02:00
|
|
|
void (*itxm_add)(int16_t *input, uint8_t *dest, int stride, int eob);
|
|
|
|
void (*itxm_add_y_block)(int16_t *q, uint8_t *dst, int stride,
|
|
|
|
struct macroblockd *xd);
|
|
|
|
void (*itxm_add_uv_block)(int16_t *q, uint8_t *dst, int stride,
|
|
|
|
uint16_t *eobs);
|
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-05-01 01:13:20 +02:00
|
|
|
int sb_index; // index of 32x32 block inside the 64x64 block
|
|
|
|
int mb_index; // index of 16x16 block inside the 32x32 block
|
|
|
|
int b_index; // index of 8x8 block inside the 16x16 block
|
2013-05-11 22:24:03 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
int ab_index; // index of 4x4 block inside the 8x8 block
|
|
|
|
#endif
|
2012-06-25 21:26:09 +02:00
|
|
|
int q_index;
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
} MACROBLOCKD;
|
|
|
|
|
2013-05-11 22:24:03 +02:00
|
|
|
static int *get_sb_index(MACROBLOCKD *xd, BLOCK_SIZE_TYPE subsize) {
|
|
|
|
switch (subsize) {
|
|
|
|
case BLOCK_SIZE_SB64X32:
|
|
|
|
case BLOCK_SIZE_SB32X64:
|
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
return &xd->sb_index;
|
|
|
|
case BLOCK_SIZE_SB32X16:
|
|
|
|
case BLOCK_SIZE_SB16X32:
|
|
|
|
case BLOCK_SIZE_MB16X16:
|
|
|
|
return &xd->mb_index;
|
|
|
|
case BLOCK_SIZE_SB16X8:
|
|
|
|
case BLOCK_SIZE_SB8X16:
|
|
|
|
case BLOCK_SIZE_SB8X8:
|
|
|
|
return &xd->b_index;
|
|
|
|
#if CONFIG_AB4X4
|
|
|
|
case BLOCK_SIZE_SB8X4:
|
|
|
|
case BLOCK_SIZE_SB4X8:
|
|
|
|
case BLOCK_SIZE_AB4X4:
|
|
|
|
return &xd->ab_index;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-23 19:12:18 +02:00
|
|
|
static INLINE void update_partition_context(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE sb_type,
|
|
|
|
BLOCK_SIZE_TYPE sb_size) {
|
2013-05-08 00:36:30 +02:00
|
|
|
int bsl = mi_width_log2(sb_size), bs = 1 << bsl;
|
2013-05-01 01:13:20 +02:00
|
|
|
int bwl = mi_width_log2(sb_type);
|
|
|
|
int bhl = mi_height_log2(sb_type);
|
|
|
|
int boffset = mi_width_log2(BLOCK_SIZE_SB64X64) - bsl;
|
2013-04-23 19:12:18 +02:00
|
|
|
int i;
|
2013-05-11 02:06:37 +02:00
|
|
|
|
|
|
|
#if !CONFIG_AB4X4
|
|
|
|
// skip 8x8 block partition
|
2013-04-23 19:12:18 +02:00
|
|
|
if (bsl == 0)
|
|
|
|
return;
|
2013-05-11 02:06:37 +02:00
|
|
|
#endif
|
2013-04-23 19:12:18 +02:00
|
|
|
|
|
|
|
// update the partition context at the end notes. set partition bits
|
|
|
|
// of block sizes larger than the current one to be one, and partition
|
|
|
|
// bits of smaller block sizes to be zero.
|
|
|
|
if ((bwl == bsl) && (bhl == bsl)) {
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->left_seg_context[i] = ~(0xf << boffset);
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->above_seg_context[i] = ~(0xf << boffset);
|
|
|
|
} else if ((bwl == bsl) && (bhl < bsl)) {
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->left_seg_context[i] = ~(0xe << boffset);
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->above_seg_context[i] = ~(0xf << boffset);
|
|
|
|
} else if ((bwl < bsl) && (bhl == bsl)) {
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->left_seg_context[i] = ~(0xf << boffset);
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->above_seg_context[i] = ~(0xe << boffset);
|
|
|
|
} else if ((bwl < bsl) && (bhl < bsl)) {
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->left_seg_context[i] = ~(0xe << boffset);
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
xd->above_seg_context[i] = ~(0xe << boffset);
|
|
|
|
} else {
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE int partition_plane_context(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE sb_type) {
|
2013-05-08 00:36:30 +02:00
|
|
|
int bsl = mi_width_log2(sb_type), bs = 1 << bsl;
|
2013-04-23 19:12:18 +02:00
|
|
|
int above = 0, left = 0, i;
|
2013-05-01 01:13:20 +02:00
|
|
|
int boffset = mi_width_log2(BLOCK_SIZE_SB64X64) - bsl;
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
assert(mi_width_log2(sb_type) == mi_height_log2(sb_type));
|
2013-04-23 19:12:18 +02:00
|
|
|
assert(bsl >= 0);
|
|
|
|
assert(boffset >= 0);
|
|
|
|
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
above |= (xd->above_seg_context[i] & (1 << boffset));
|
|
|
|
for (i = 0; i < bs; i++)
|
|
|
|
left |= (xd->left_seg_context[i] & (1 << boffset));
|
|
|
|
|
|
|
|
above = (above > 0);
|
|
|
|
left = (left > 0);
|
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
return (left * 2 + above) + bsl * PARTITION_PLOFFSET;
|
|
|
|
#else
|
2013-04-23 19:12:18 +02:00
|
|
|
return (left * 2 + above) + (bsl - 1) * PARTITION_PLOFFSET;
|
2013-05-11 02:06:37 +02:00
|
|
|
#endif
|
2013-04-23 19:12:18 +02:00
|
|
|
}
|
|
|
|
|
2013-05-01 18:43:59 +02:00
|
|
|
static BLOCK_SIZE_TYPE get_subsize(BLOCK_SIZE_TYPE bsize,
|
|
|
|
PARTITION_TYPE partition) {
|
|
|
|
BLOCK_SIZE_TYPE subsize;
|
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
|
|
|
subsize = bsize;
|
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
|
|
|
if (bsize == BLOCK_SIZE_SB64X64)
|
|
|
|
subsize = BLOCK_SIZE_SB64X32;
|
|
|
|
else if (bsize == BLOCK_SIZE_SB32X32)
|
|
|
|
subsize = BLOCK_SIZE_SB32X16;
|
|
|
|
else if (bsize == BLOCK_SIZE_MB16X16)
|
|
|
|
subsize = BLOCK_SIZE_SB16X8;
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
else if (bsize == BLOCK_SIZE_SB8X8)
|
|
|
|
subsize = BLOCK_SIZE_SB8X4;
|
|
|
|
#endif
|
2013-05-01 18:43:59 +02:00
|
|
|
else
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
|
|
|
if (bsize == BLOCK_SIZE_SB64X64)
|
|
|
|
subsize = BLOCK_SIZE_SB32X64;
|
|
|
|
else if (bsize == BLOCK_SIZE_SB32X32)
|
|
|
|
subsize = BLOCK_SIZE_SB16X32;
|
|
|
|
else if (bsize == BLOCK_SIZE_MB16X16)
|
|
|
|
subsize = BLOCK_SIZE_SB8X16;
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
else if (bsize == BLOCK_SIZE_SB8X8)
|
|
|
|
subsize = BLOCK_SIZE_SB4X8;
|
|
|
|
#endif
|
2013-05-01 18:43:59 +02:00
|
|
|
else
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
|
|
|
if (bsize == BLOCK_SIZE_SB64X64)
|
|
|
|
subsize = BLOCK_SIZE_SB32X32;
|
|
|
|
else if (bsize == BLOCK_SIZE_SB32X32)
|
|
|
|
subsize = BLOCK_SIZE_MB16X16;
|
|
|
|
else if (bsize == BLOCK_SIZE_MB16X16)
|
|
|
|
subsize = BLOCK_SIZE_SB8X8;
|
2013-05-11 02:06:37 +02:00
|
|
|
#if CONFIG_AB4X4
|
|
|
|
else if (bsize == BLOCK_SIZE_SB8X8)
|
|
|
|
subsize = BLOCK_SIZE_AB4X4;
|
|
|
|
#endif
|
2013-05-01 18:43:59 +02:00
|
|
|
else
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
return subsize;
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
switch (mode) {
|
2013-02-27 20:17:38 +01:00
|
|
|
case DC_PRED: return B_DC_PRED;
|
2013-04-12 00:52:28 +02:00
|
|
|
case V_PRED: return B_V_PRED;
|
|
|
|
case H_PRED: return B_H_PRED;
|
2013-02-27 20:17:38 +01:00
|
|
|
case TM_PRED: return B_TM_PRED;
|
2013-04-12 00:52:28 +02:00
|
|
|
case D45_PRED: return B_D45_PRED;
|
|
|
|
case D135_PRED: return B_D135_PRED;
|
|
|
|
case D117_PRED: return B_D117_PRED;
|
|
|
|
case D153_PRED: return B_D153_PRED;
|
|
|
|
case D27_PRED: return B_D27_PRED;
|
|
|
|
case D63_PRED: return B_D63_PRED;
|
2013-02-27 20:17:38 +01:00
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return B_MODE_COUNT; // Dummy value
|
2012-10-16 01:41:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-02 18:07:33 +02:00
|
|
|
switch (bmode) {
|
|
|
|
case B_TM_PRED :
|
2013-04-12 00:52:28 +02:00
|
|
|
case B_D135_PRED :
|
2013-02-27 20:17:38 +01:00
|
|
|
return ADST_ADST;
|
2012-08-02 18:07:33 +02:00
|
|
|
|
2013-04-12 00:52:28 +02:00
|
|
|
case B_V_PRED :
|
|
|
|
case B_D117_PRED :
|
2013-05-14 01:51:47 +02:00
|
|
|
case B_D63_PRED:
|
2013-02-27 20:17:38 +01:00
|
|
|
return ADST_DCT;
|
2012-08-02 18:07:33 +02:00
|
|
|
|
2013-04-12 00:52:28 +02:00
|
|
|
case B_H_PRED :
|
|
|
|
case B_D153_PRED :
|
|
|
|
case B_D27_PRED :
|
2013-02-27 20:17:38 +01:00
|
|
|
return DCT_ADST;
|
2012-08-02 18:07:33 +02:00
|
|
|
|
2013-02-27 20:17:38 +01:00
|
|
|
default:
|
|
|
|
return DCT_DCT;
|
2012-08-02 18:07:33 +02:00
|
|
|
}
|
2012-10-16 01:41:41 +02:00
|
|
|
}
|
|
|
|
|
2013-03-07 18:17:35 +01:00
|
|
|
#define USE_ADST_FOR_I16X16_8X8 1
|
|
|
|
#define USE_ADST_FOR_I16X16_4X4 1
|
2012-11-16 00:14:38 +01:00
|
|
|
#define USE_ADST_FOR_I8X8_4X4 1
|
|
|
|
#define USE_ADST_PERIPHERY_ONLY 1
|
2013-03-07 18:17:35 +01:00
|
|
|
#define USE_ADST_FOR_SB 1
|
|
|
|
#define USE_ADST_FOR_REMOTE_EDGE 0
|
2012-11-16 00:14:38 +01:00
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
static TX_TYPE get_tx_type_4x4(const MACROBLOCKD *xd, int ib) {
|
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;
|
2013-03-07 18:17:35 +01:00
|
|
|
const BLOCK_SIZE_TYPE sb_type = xd->mode_info_context->mbmi.sb_type;
|
2013-04-24 18:18:16 +02:00
|
|
|
const int wb = b_width_log2(sb_type), hb = b_height_log2(sb_type);
|
2013-03-07 18:17:35 +01:00
|
|
|
#if !USE_ADST_FOR_SB
|
2013-04-10 06:28:27 +02:00
|
|
|
if (sb_type > BLOCK_SIZE_MB16X16)
|
2013-03-06 00:18:06 +01:00
|
|
|
return tx_type;
|
2013-03-07 18:17:35 +01:00
|
|
|
#endif
|
2013-04-24 18:18:16 +02:00
|
|
|
if (ib >= (1 << (wb + hb))) // no chroma adst
|
2012-11-16 00:14:38 +01:00
|
|
|
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;
|
2013-04-11 21:16:35 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode == I4X4_PRED &&
|
2012-10-16 01:41:41 +02:00
|
|
|
xd->q_index < ACTIVE_HT) {
|
2012-10-09 22:19:15 +02:00
|
|
|
tx_type = txfm_map(
|
2013-04-26 16:19:43 +02:00
|
|
|
xd->mode_info_context->bmi[ib].as_mode.first);
|
2013-05-01 01:13:20 +02:00
|
|
|
} else if (xd->mode_info_context->mbmi.mode <= TM_PRED &&
|
2012-11-16 00:14:38 +01:00
|
|
|
xd->q_index < ACTIVE_HT) {
|
|
|
|
#if USE_ADST_FOR_I16X16_4X4
|
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
2013-04-24 18:18:16 +02:00
|
|
|
const int hmax = 1 << wb;
|
2013-03-07 18:17:35 +01:00
|
|
|
tx_type = txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode));
|
|
|
|
#if USE_ADST_FOR_REMOTE_EDGE
|
|
|
|
if ((ib & (hmax - 1)) != 0 && ib >= hmax)
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#else
|
|
|
|
if (ib >= 1 && ib < hmax) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = ADST_DCT;
|
|
|
|
else if (tx_type == DCT_ADST) tx_type = DCT_DCT;
|
|
|
|
} else if (ib >= 1 && (ib & (hmax - 1)) == 0) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = DCT_ADST;
|
|
|
|
else if (tx_type == ADST_DCT) tx_type = DCT_DCT;
|
|
|
|
} else if (ib != 0) {
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
}
|
|
|
|
#endif
|
2012-11-16 00:14:38 +01:00
|
|
|
#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;
|
|
|
|
}
|
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
static TX_TYPE get_tx_type_8x8(const MACROBLOCKD *xd, int ib) {
|
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;
|
2013-03-07 18:17:35 +01:00
|
|
|
const BLOCK_SIZE_TYPE sb_type = xd->mode_info_context->mbmi.sb_type;
|
2013-04-24 18:18:16 +02:00
|
|
|
const int wb = b_width_log2(sb_type), hb = b_height_log2(sb_type);
|
2013-03-07 18:17:35 +01:00
|
|
|
#if !USE_ADST_FOR_SB
|
2013-04-10 06:28:27 +02:00
|
|
|
if (sb_type > BLOCK_SIZE_MB16X16)
|
2012-11-16 00:14:38 +01:00
|
|
|
return tx_type;
|
2013-03-07 18:17:35 +01:00
|
|
|
#endif
|
2013-04-24 18:18:16 +02:00
|
|
|
if (ib >= (1 << (wb + hb))) // no chroma adst
|
2013-03-06 00:18:06 +01:00
|
|
|
return tx_type;
|
2013-05-01 01:13:20 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode <= TM_PRED &&
|
|
|
|
xd->q_index < ACTIVE_HT8) {
|
2013-03-07 18:17:35 +01:00
|
|
|
#if USE_ADST_FOR_I16X16_8X8
|
2012-11-16 00:14:38 +01:00
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
2013-04-24 18:18:16 +02:00
|
|
|
const int hmax = 1 << wb;
|
2013-03-07 18:17:35 +01:00
|
|
|
tx_type = txfm_map(pred_mode_conv(xd->mode_info_context->mbmi.mode));
|
|
|
|
#if USE_ADST_FOR_REMOTE_EDGE
|
|
|
|
if ((ib & (hmax - 1)) != 0 && ib >= hmax)
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#else
|
|
|
|
if (ib >= 1 && ib < hmax) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = ADST_DCT;
|
|
|
|
else if (tx_type == DCT_ADST) tx_type = DCT_DCT;
|
|
|
|
} else if (ib >= 1 && (ib & (hmax - 1)) == 0) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = DCT_ADST;
|
|
|
|
else if (tx_type == ADST_DCT) tx_type = DCT_DCT;
|
|
|
|
} else if (ib != 0) {
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
}
|
|
|
|
#endif
|
2012-11-16 00:14:38 +01:00
|
|
|
#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
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
static TX_TYPE get_tx_type_16x16(const MACROBLOCKD *xd, int ib) {
|
2012-10-16 01:41:41 +02:00
|
|
|
TX_TYPE tx_type = DCT_DCT;
|
2013-03-07 18:17:35 +01:00
|
|
|
const BLOCK_SIZE_TYPE sb_type = xd->mode_info_context->mbmi.sb_type;
|
2013-04-24 18:18:16 +02:00
|
|
|
const int wb = b_width_log2(sb_type), hb = b_height_log2(sb_type);
|
2013-03-07 18:17:35 +01:00
|
|
|
#if !USE_ADST_FOR_SB
|
2013-04-10 06:28:27 +02:00
|
|
|
if (sb_type > BLOCK_SIZE_MB16X16)
|
2013-03-07 18:17:35 +01:00
|
|
|
return tx_type;
|
|
|
|
#endif
|
2013-04-24 18:18:16 +02:00
|
|
|
if (ib >= (1 << (wb + hb)))
|
2012-11-16 00:14:38 +01:00
|
|
|
return tx_type;
|
2013-05-01 01:13:20 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode <= TM_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));
|
2013-03-07 18:17:35 +01:00
|
|
|
#if USE_ADST_PERIPHERY_ONLY
|
2013-04-10 06:28:27 +02:00
|
|
|
if (sb_type > BLOCK_SIZE_MB16X16) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int hmax = 1 << wb;
|
2013-03-07 18:17:35 +01:00
|
|
|
#if USE_ADST_FOR_REMOTE_EDGE
|
|
|
|
if ((ib & (hmax - 1)) != 0 && ib >= hmax)
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
#else
|
|
|
|
if (ib >= 1 && ib < hmax) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = ADST_DCT;
|
|
|
|
else if (tx_type == DCT_ADST) tx_type = DCT_DCT;
|
|
|
|
} else if (ib >= 1 && (ib & (hmax - 1)) == 0) {
|
|
|
|
if (tx_type == ADST_ADST) tx_type = DCT_ADST;
|
|
|
|
else if (tx_type == ADST_DCT) tx_type = DCT_DCT;
|
|
|
|
} else if (ib != 0) {
|
|
|
|
tx_type = DCT_DCT;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
2012-10-16 01:41:41 +02:00
|
|
|
}
|
|
|
|
return tx_type;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:52:06 +02:00
|
|
|
void vp9_setup_block_dptrs(MACROBLOCKD *xd,
|
|
|
|
int subsampling_x, int subsampling_y);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-02-20 19:16:24 +01:00
|
|
|
static TX_SIZE get_uv_tx_size(const MACROBLOCKD *xd) {
|
2013-04-02 03:23:04 +02:00
|
|
|
MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
|
|
|
|
const TX_SIZE size = mbmi->txfm_size;
|
|
|
|
|
|
|
|
switch (mbmi->sb_type) {
|
|
|
|
case BLOCK_SIZE_SB64X64:
|
|
|
|
return size;
|
2013-04-10 06:28:27 +02:00
|
|
|
case BLOCK_SIZE_SB64X32:
|
|
|
|
case BLOCK_SIZE_SB32X64:
|
2013-04-02 03:23:04 +02:00
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
if (size == TX_32X32)
|
|
|
|
return TX_16X16;
|
|
|
|
else
|
|
|
|
return size;
|
2013-05-01 01:13:20 +02:00
|
|
|
case BLOCK_SIZE_SB32X16:
|
|
|
|
case BLOCK_SIZE_SB16X32:
|
|
|
|
case BLOCK_SIZE_MB16X16:
|
|
|
|
if (size == TX_16X16)
|
|
|
|
return TX_8X8;
|
|
|
|
else
|
|
|
|
return size;
|
|
|
|
default:
|
|
|
|
return TX_4X4;
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
2013-04-02 03:23:04 +02:00
|
|
|
|
|
|
|
return size;
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
2013-03-26 23:23:30 +01:00
|
|
|
|
2013-04-02 23:50:40 +02:00
|
|
|
struct plane_block_idx {
|
|
|
|
int plane;
|
|
|
|
int block;
|
|
|
|
};
|
|
|
|
|
|
|
|
// TODO(jkoleszar): returning a struct so it can be used in a const context,
|
|
|
|
// expect to refactor this further later.
|
2013-04-04 21:03:27 +02:00
|
|
|
static INLINE struct plane_block_idx plane_block_idx(int y_blocks,
|
2013-03-28 18:42:23 +01:00
|
|
|
int b_idx) {
|
2013-04-04 21:03:27 +02:00
|
|
|
const int v_offset = y_blocks * 5 / 4;
|
2013-04-02 23:50:40 +02:00
|
|
|
struct plane_block_idx res;
|
|
|
|
|
2013-04-04 21:03:27 +02:00
|
|
|
if (b_idx < y_blocks) {
|
2013-04-02 23:50:40 +02:00
|
|
|
res.plane = 0;
|
|
|
|
res.block = b_idx;
|
|
|
|
} else if (b_idx < v_offset) {
|
|
|
|
res.plane = 1;
|
2013-04-04 21:03:27 +02:00
|
|
|
res.block = b_idx - y_blocks;
|
2013-04-02 23:50:40 +02:00
|
|
|
} else {
|
2013-04-04 21:03:27 +02:00
|
|
|
assert(b_idx < y_blocks * 3 / 2);
|
2013-04-02 23:50:40 +02:00
|
|
|
res.plane = 2;
|
|
|
|
res.block = b_idx - v_offset;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2013-04-09 19:15:10 +02:00
|
|
|
typedef void (*foreach_transformed_block_visitor)(int plane, int block,
|
2013-04-12 23:12:05 +02:00
|
|
|
BLOCK_SIZE_TYPE bsize,
|
2013-04-09 19:15:10 +02:00
|
|
|
int ss_txfrm_size,
|
|
|
|
void *arg);
|
|
|
|
static INLINE void foreach_transformed_block_in_plane(
|
2013-04-12 23:12:05 +02:00
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize, int plane,
|
2013-05-01 01:13:20 +02:00
|
|
|
foreach_transformed_block_visitor visit, void *arg) {
|
2013-04-12 23:12:05 +02:00
|
|
|
const int bw = b_width_log2(bsize), bh = b_height_log2(bsize);
|
|
|
|
|
2013-04-09 19:15:10 +02:00
|
|
|
// block and transform sizes, in number of 4x4 blocks log 2 ("*_b")
|
|
|
|
// 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
|
2013-05-07 23:44:12 +02:00
|
|
|
// transform size varies per plane, look it up in a common way.
|
|
|
|
const TX_SIZE tx_size = plane ? get_uv_tx_size(xd)
|
|
|
|
: xd->mode_info_context->mbmi.txfm_size;
|
2013-04-12 23:12:05 +02:00
|
|
|
const int block_size_b = bw + bh;
|
2013-04-09 19:15:10 +02:00
|
|
|
const int txfrm_size_b = tx_size * 2;
|
|
|
|
|
|
|
|
// subsampled size of the block
|
|
|
|
const int ss_sum = xd->plane[plane].subsampling_x +
|
|
|
|
xd->plane[plane].subsampling_y;
|
|
|
|
const int ss_block_size = block_size_b - ss_sum;
|
|
|
|
|
2013-05-07 23:44:12 +02:00
|
|
|
const int step = 1 << txfrm_size_b;
|
2013-04-09 19:15:10 +02:00
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
assert(txfrm_size_b <= block_size_b);
|
2013-05-07 23:44:12 +02:00
|
|
|
assert(txfrm_size_b <= ss_block_size);
|
2013-04-12 23:12:05 +02:00
|
|
|
for (i = 0; i < (1 << ss_block_size); i += step) {
|
2013-05-07 23:44:12 +02:00
|
|
|
visit(plane, i, bsize, txfrm_size_b, arg);
|
2013-04-09 19:15:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE void foreach_transformed_block(
|
2013-04-12 23:12:05 +02:00
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
|
2013-04-09 19:15:10 +02:00
|
|
|
foreach_transformed_block_visitor visit, void *arg) {
|
|
|
|
int plane;
|
|
|
|
|
|
|
|
for (plane = 0; plane < MAX_MB_PLANE; plane++) {
|
2013-05-01 01:13:20 +02:00
|
|
|
foreach_transformed_block_in_plane(xd, bsize, plane,
|
2013-04-09 19:15:10 +02:00
|
|
|
visit, arg);
|
|
|
|
}
|
|
|
|
}
|
2013-04-02 23:50:40 +02:00
|
|
|
|
2013-04-11 20:14:31 +02:00
|
|
|
static INLINE void foreach_transformed_block_uv(
|
2013-04-12 23:12:05 +02:00
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
|
2013-04-11 20:14:31 +02:00
|
|
|
foreach_transformed_block_visitor visit, void *arg) {
|
|
|
|
int plane;
|
|
|
|
|
|
|
|
for (plane = 1; plane < MAX_MB_PLANE; plane++) {
|
2013-05-01 01:13:20 +02:00
|
|
|
foreach_transformed_block_in_plane(xd, bsize, plane,
|
2013-04-11 20:14:31 +02:00
|
|
|
visit, arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
make buid_inter_predictors block size agnostic (luma)
This commit converts the luma versions of vp9_build_inter_predictors_sb
to use a common function. Update the convolution functions to support
block sizes larger than 16x16, and add a foreach_predicted_block walker.
Next step will be to calculate the UV motion vector and implement SBUV,
then fold in vp9_build_inter16x16_predictors_mb and SPLITMV.
At the 16x16, 32x32, and 64x64 levels implemented in this commit, each
plane is predicted with only a single call to vp9_build_inter_predictor.
This is not yet called for SPLITMV. If the notion of SPLITMV/I8X8/I4X4
goes away, then the prediction block walker can go away, since we'll
always predict the whole bsize in a single step. Implemented using a
block walker at this stage for SPLITMV, as a 4x4 "prediction block size"
within the BLOCK_SIZE_MB16X16 macroblock. It would also support other
rectangular sizes too, if the blocks smaller than 16x16 remain
implemented as a SPLITMV-like thing. Just using 4x4 for now.
There's also a potential to combine with the foreach_transformed_block
walker if the logic for calculating the size of the subsampled
transform is made more straightforward, perhaps as a consequence of
supporing smaller macroblocks than 16x16. Will watch what happens there.
Change-Id: Iddd9973398542216601b630c628b9b7fdee33fe2
2013-04-13 02:19:57 +02:00
|
|
|
// TODO(jkoleszar): In principle, pred_w, pred_h are unnecessary, as we could
|
|
|
|
// calculate the subsampled BLOCK_SIZE_TYPE, but that type isn't defined for
|
|
|
|
// sizes smaller than 16x16 yet.
|
|
|
|
typedef void (*foreach_predicted_block_visitor)(int plane, int block,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int pred_w, int pred_h,
|
|
|
|
void *arg);
|
|
|
|
static INLINE void foreach_predicted_block_in_plane(
|
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize, int plane,
|
|
|
|
foreach_predicted_block_visitor visit, void *arg) {
|
2013-04-17 22:41:18 +02:00
|
|
|
int i, x, y;
|
|
|
|
const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
|
make buid_inter_predictors block size agnostic (luma)
This commit converts the luma versions of vp9_build_inter_predictors_sb
to use a common function. Update the convolution functions to support
block sizes larger than 16x16, and add a foreach_predicted_block walker.
Next step will be to calculate the UV motion vector and implement SBUV,
then fold in vp9_build_inter16x16_predictors_mb and SPLITMV.
At the 16x16, 32x32, and 64x64 levels implemented in this commit, each
plane is predicted with only a single call to vp9_build_inter_predictor.
This is not yet called for SPLITMV. If the notion of SPLITMV/I8X8/I4X4
goes away, then the prediction block walker can go away, since we'll
always predict the whole bsize in a single step. Implemented using a
block walker at this stage for SPLITMV, as a 4x4 "prediction block size"
within the BLOCK_SIZE_MB16X16 macroblock. It would also support other
rectangular sizes too, if the blocks smaller than 16x16 remain
implemented as a SPLITMV-like thing. Just using 4x4 for now.
There's also a potential to combine with the foreach_transformed_block
walker if the logic for calculating the size of the subsampled
transform is made more straightforward, perhaps as a consequence of
supporing smaller macroblocks than 16x16. Will watch what happens there.
Change-Id: Iddd9973398542216601b630c628b9b7fdee33fe2
2013-04-13 02:19:57 +02:00
|
|
|
|
|
|
|
// block sizes in number of 4x4 blocks log 2 ("*_b")
|
|
|
|
// 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
|
|
|
|
// subsampled size of the block
|
2013-04-17 22:41:18 +02:00
|
|
|
const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
|
|
|
|
const int bh = b_height_log2(bsize) - xd->plane[plane].subsampling_y;
|
make buid_inter_predictors block size agnostic (luma)
This commit converts the luma versions of vp9_build_inter_predictors_sb
to use a common function. Update the convolution functions to support
block sizes larger than 16x16, and add a foreach_predicted_block walker.
Next step will be to calculate the UV motion vector and implement SBUV,
then fold in vp9_build_inter16x16_predictors_mb and SPLITMV.
At the 16x16, 32x32, and 64x64 levels implemented in this commit, each
plane is predicted with only a single call to vp9_build_inter_predictor.
This is not yet called for SPLITMV. If the notion of SPLITMV/I8X8/I4X4
goes away, then the prediction block walker can go away, since we'll
always predict the whole bsize in a single step. Implemented using a
block walker at this stage for SPLITMV, as a 4x4 "prediction block size"
within the BLOCK_SIZE_MB16X16 macroblock. It would also support other
rectangular sizes too, if the blocks smaller than 16x16 remain
implemented as a SPLITMV-like thing. Just using 4x4 for now.
There's also a potential to combine with the foreach_transformed_block
walker if the logic for calculating the size of the subsampled
transform is made more straightforward, perhaps as a consequence of
supporing smaller macroblocks than 16x16. Will watch what happens there.
Change-Id: Iddd9973398542216601b630c628b9b7fdee33fe2
2013-04-13 02:19:57 +02:00
|
|
|
|
|
|
|
// size of the predictor to use.
|
2013-04-17 22:41:18 +02:00
|
|
|
int pred_w, pred_h;
|
|
|
|
|
|
|
|
if (mode == SPLITMV) {
|
2013-05-01 01:13:20 +02:00
|
|
|
pred_w = 0;
|
|
|
|
pred_h = 0;
|
2013-04-17 22:41:18 +02:00
|
|
|
} else {
|
|
|
|
pred_w = bw;
|
|
|
|
pred_h = bh;
|
|
|
|
}
|
|
|
|
assert(pred_w <= bw);
|
|
|
|
assert(pred_h <= bh);
|
|
|
|
|
|
|
|
// visit each subblock in raster order
|
|
|
|
i = 0;
|
|
|
|
for (y = 0; y < 1 << bh; y += 1 << pred_h) {
|
|
|
|
for (x = 0; x < 1 << bw; x += 1 << pred_w) {
|
|
|
|
visit(plane, i, bsize, pred_w, pred_h, arg);
|
|
|
|
i += 1 << pred_w;
|
|
|
|
}
|
|
|
|
i -= 1 << bw;
|
|
|
|
i += 1 << (bw + pred_h);
|
make buid_inter_predictors block size agnostic (luma)
This commit converts the luma versions of vp9_build_inter_predictors_sb
to use a common function. Update the convolution functions to support
block sizes larger than 16x16, and add a foreach_predicted_block walker.
Next step will be to calculate the UV motion vector and implement SBUV,
then fold in vp9_build_inter16x16_predictors_mb and SPLITMV.
At the 16x16, 32x32, and 64x64 levels implemented in this commit, each
plane is predicted with only a single call to vp9_build_inter_predictor.
This is not yet called for SPLITMV. If the notion of SPLITMV/I8X8/I4X4
goes away, then the prediction block walker can go away, since we'll
always predict the whole bsize in a single step. Implemented using a
block walker at this stage for SPLITMV, as a 4x4 "prediction block size"
within the BLOCK_SIZE_MB16X16 macroblock. It would also support other
rectangular sizes too, if the blocks smaller than 16x16 remain
implemented as a SPLITMV-like thing. Just using 4x4 for now.
There's also a potential to combine with the foreach_transformed_block
walker if the logic for calculating the size of the subsampled
transform is made more straightforward, perhaps as a consequence of
supporing smaller macroblocks than 16x16. Will watch what happens there.
Change-Id: Iddd9973398542216601b630c628b9b7fdee33fe2
2013-04-13 02:19:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
static INLINE void foreach_predicted_block(
|
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
|
|
|
|
foreach_predicted_block_visitor visit, void *arg) {
|
|
|
|
int plane;
|
|
|
|
|
|
|
|
for (plane = 0; plane < MAX_MB_PLANE; plane++) {
|
|
|
|
foreach_predicted_block_in_plane(xd, bsize, plane, visit, arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static INLINE void foreach_predicted_block_uv(
|
|
|
|
const MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
|
|
|
|
foreach_predicted_block_visitor visit, void *arg) {
|
|
|
|
int plane;
|
|
|
|
|
|
|
|
for (plane = 1; plane < MAX_MB_PLANE; plane++) {
|
|
|
|
foreach_predicted_block_in_plane(xd, bsize, plane, visit, arg);
|
|
|
|
}
|
|
|
|
}
|
2013-04-23 17:26:10 +02:00
|
|
|
static int raster_block_offset(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
|
2013-04-24 01:22:47 +02:00
|
|
|
int plane, int block, int stride) {
|
2013-04-23 17:26:10 +02:00
|
|
|
const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
|
|
|
|
const int y = 4 * (block >> bw), x = 4 * (block & ((1 << bw) - 1));
|
|
|
|
return y * stride + x;
|
|
|
|
}
|
|
|
|
static int16_t* raster_block_offset_int16(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int plane, int block, int16_t *base) {
|
2013-04-24 01:22:47 +02:00
|
|
|
const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
|
|
|
|
const int stride = 4 << bw;
|
|
|
|
return base + raster_block_offset(xd, bsize, plane, block, stride);
|
|
|
|
}
|
|
|
|
static uint8_t* raster_block_offset_uint8(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int plane, int block,
|
|
|
|
uint8_t *base, int stride) {
|
|
|
|
return base + raster_block_offset(xd, bsize, plane, block, stride);
|
2013-04-23 17:26:10 +02:00
|
|
|
}
|
make buid_inter_predictors block size agnostic (luma)
This commit converts the luma versions of vp9_build_inter_predictors_sb
to use a common function. Update the convolution functions to support
block sizes larger than 16x16, and add a foreach_predicted_block walker.
Next step will be to calculate the UV motion vector and implement SBUV,
then fold in vp9_build_inter16x16_predictors_mb and SPLITMV.
At the 16x16, 32x32, and 64x64 levels implemented in this commit, each
plane is predicted with only a single call to vp9_build_inter_predictor.
This is not yet called for SPLITMV. If the notion of SPLITMV/I8X8/I4X4
goes away, then the prediction block walker can go away, since we'll
always predict the whole bsize in a single step. Implemented using a
block walker at this stage for SPLITMV, as a 4x4 "prediction block size"
within the BLOCK_SIZE_MB16X16 macroblock. It would also support other
rectangular sizes too, if the blocks smaller than 16x16 remain
implemented as a SPLITMV-like thing. Just using 4x4 for now.
There's also a potential to combine with the foreach_transformed_block
walker if the logic for calculating the size of the subsampled
transform is made more straightforward, perhaps as a consequence of
supporing smaller macroblocks than 16x16. Will watch what happens there.
Change-Id: Iddd9973398542216601b630c628b9b7fdee33fe2
2013-04-13 02:19:57 +02:00
|
|
|
|
2013-04-30 18:54:51 +02:00
|
|
|
static int txfrm_block_to_raster_block(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int plane, int block,
|
|
|
|
int ss_txfrm_size) {
|
|
|
|
const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
|
|
|
|
const int txwl = ss_txfrm_size / 2;
|
|
|
|
const int tx_cols_lg2 = bwl - txwl;
|
|
|
|
const int tx_cols = 1 << tx_cols_lg2;
|
|
|
|
const int raster_mb = block >> ss_txfrm_size;
|
|
|
|
const int x = (raster_mb & (tx_cols - 1)) << (txwl);
|
|
|
|
const int y = raster_mb >> tx_cols_lg2 << (txwl);
|
|
|
|
return x + (y << bwl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void txfrm_block_to_raster_xy(MACROBLOCKD *xd,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int plane, int block,
|
|
|
|
int ss_txfrm_size,
|
|
|
|
int *x, int *y) {
|
|
|
|
const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
|
|
|
|
const int txwl = ss_txfrm_size / 2;
|
|
|
|
const int tx_cols_lg2 = bwl - txwl;
|
|
|
|
const int tx_cols = 1 << tx_cols_lg2;
|
|
|
|
const int raster_mb = block >> ss_txfrm_size;
|
|
|
|
*x = (raster_mb & (tx_cols - 1)) << (txwl);
|
|
|
|
*y = raster_mb >> tx_cols_lg2 << (txwl);
|
|
|
|
}
|
|
|
|
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_COMMON_VP9_BLOCKD_H_
|