312 lines
8.3 KiB
C++
312 lines
8.3 KiB
C++
/*
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
|
|
#ifndef VP8_COMMON_BLOCKD_H_
|
|
#define VP8_COMMON_BLOCKD_H_
|
|
|
|
void vpx_log(const char *format, ...);
|
|
|
|
#include "vpx_config.h"
|
|
#include "vpx_scale/yv12config.h"
|
|
#include "mv.h"
|
|
#include "treecoder.h"
|
|
#include "vpx_ports/mem.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*#define DCPRED 1*/
|
|
#define DCPREDSIMTHRESH 0
|
|
#define DCPREDCNTTHRESH 3
|
|
|
|
#define MB_FEATURE_TREE_PROBS 3
|
|
#define MAX_MB_SEGMENTS 4
|
|
|
|
#define MAX_REF_LF_DELTAS 4
|
|
#define MAX_MODE_LF_DELTAS 4
|
|
|
|
/* Segment Feature Masks */
|
|
#define SEGMENT_DELTADATA 0
|
|
#define SEGMENT_ABSDATA 1
|
|
|
|
typedef struct
|
|
{
|
|
int r, c;
|
|
} POS;
|
|
|
|
#define PLANE_TYPE_Y_NO_DC 0
|
|
#define PLANE_TYPE_Y2 1
|
|
#define PLANE_TYPE_UV 2
|
|
#define PLANE_TYPE_Y_WITH_DC 3
|
|
|
|
|
|
typedef char ENTROPY_CONTEXT;
|
|
typedef struct
|
|
{
|
|
ENTROPY_CONTEXT y1[4];
|
|
ENTROPY_CONTEXT u[2];
|
|
ENTROPY_CONTEXT v[2];
|
|
ENTROPY_CONTEXT y2;
|
|
} ENTROPY_CONTEXT_PLANES;
|
|
|
|
extern const unsigned char vp8_block2left[25];
|
|
extern const unsigned char vp8_block2above[25];
|
|
|
|
#define VP8_COMBINEENTROPYCONTEXTS( Dest, A, B) \
|
|
Dest = (A)+(B);
|
|
|
|
|
|
typedef enum
|
|
{
|
|
KEY_FRAME = 0,
|
|
INTER_FRAME = 1
|
|
} FRAME_TYPE;
|
|
|
|
typedef enum
|
|
{
|
|
DC_PRED, /* average of above and left pixels */
|
|
V_PRED, /* vertical prediction */
|
|
H_PRED, /* horizontal prediction */
|
|
TM_PRED, /* Truemotion prediction */
|
|
B_PRED, /* block based prediction, each block has its own prediction mode */
|
|
|
|
NEARESTMV,
|
|
NEARMV,
|
|
ZEROMV,
|
|
NEWMV,
|
|
SPLITMV,
|
|
|
|
MB_MODE_COUNT
|
|
} MB_PREDICTION_MODE;
|
|
|
|
/* Macroblock level features */
|
|
typedef enum
|
|
{
|
|
MB_LVL_ALT_Q = 0, /* Use alternate Quantizer .... */
|
|
MB_LVL_ALT_LF = 1, /* Use alternate loop filter value... */
|
|
MB_LVL_MAX = 2 /* Number of MB level features supported */
|
|
|
|
} MB_LVL_FEATURES;
|
|
|
|
/* Segment Feature Masks */
|
|
#define SEGMENT_ALTQ 0x01
|
|
#define SEGMENT_ALT_LF 0x02
|
|
|
|
#define VP8_YMODES (B_PRED + 1)
|
|
#define VP8_UV_MODES (TM_PRED + 1)
|
|
|
|
#define VP8_MVREFS (1 + SPLITMV - NEARESTMV)
|
|
|
|
typedef enum
|
|
{
|
|
B_DC_PRED, /* average of above and left pixels */
|
|
B_TM_PRED,
|
|
|
|
B_VE_PRED, /* vertical prediction */
|
|
B_HE_PRED, /* horizontal prediction */
|
|
|
|
B_LD_PRED,
|
|
B_RD_PRED,
|
|
|
|
B_VR_PRED,
|
|
B_VL_PRED,
|
|
B_HD_PRED,
|
|
B_HU_PRED,
|
|
|
|
LEFT4X4,
|
|
ABOVE4X4,
|
|
ZERO4X4,
|
|
NEW4X4,
|
|
|
|
B_MODE_COUNT
|
|
} B_PREDICTION_MODE;
|
|
|
|
#define VP8_BINTRAMODES (B_HU_PRED + 1) /* 10 */
|
|
#define VP8_SUBMVREFS (1 + NEW4X4 - LEFT4X4)
|
|
|
|
/* 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. */
|
|
|
|
union b_mode_info
|
|
{
|
|
B_PREDICTION_MODE as_mode;
|
|
int_mv mv;
|
|
};
|
|
|
|
typedef enum
|
|
{
|
|
INTRA_FRAME = 0,
|
|
LAST_FRAME = 1,
|
|
GOLDEN_FRAME = 2,
|
|
ALTREF_FRAME = 3,
|
|
MAX_REF_FRAMES = 4
|
|
} MV_REFERENCE_FRAME;
|
|
|
|
typedef struct
|
|
{
|
|
uint8_t mode, uv_mode;
|
|
uint8_t ref_frame;
|
|
uint8_t is_4x4;
|
|
int_mv mv;
|
|
|
|
uint8_t partitioning;
|
|
uint8_t mb_skip_coeff; /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
|
|
uint8_t need_to_clamp_mvs;
|
|
uint8_t segment_id; /* Which set of segmentation parameters should be used for this MB */
|
|
} MB_MODE_INFO;
|
|
|
|
typedef struct modeinfo
|
|
{
|
|
MB_MODE_INFO mbmi;
|
|
union b_mode_info bmi[16];
|
|
} MODE_INFO;
|
|
|
|
#if CONFIG_MULTI_RES_ENCODING
|
|
/* The mb-level information needed to be stored for higher-resolution encoder */
|
|
typedef struct
|
|
{
|
|
MB_PREDICTION_MODE mode;
|
|
MV_REFERENCE_FRAME ref_frame;
|
|
int_mv mv;
|
|
int dissim; /* dissimilarity level of the macroblock */
|
|
} LOWER_RES_MB_INFO;
|
|
|
|
/* The frame-level information needed to be stored for higher-resolution
|
|
* encoder */
|
|
typedef struct
|
|
{
|
|
FRAME_TYPE frame_type;
|
|
int is_frame_dropped;
|
|
// The frame rate for the lowest resolution.
|
|
double low_res_framerate;
|
|
/* The frame number of each reference frames */
|
|
unsigned int low_res_ref_frames[MAX_REF_FRAMES];
|
|
// The video frame counter value for the key frame, for lowest resolution.
|
|
unsigned int key_frame_counter_value;
|
|
LOWER_RES_MB_INFO *mb_info;
|
|
} LOWER_RES_FRAME_INFO;
|
|
#endif
|
|
|
|
typedef struct blockd
|
|
{
|
|
short *qcoeff;
|
|
short *dqcoeff;
|
|
unsigned char *predictor;
|
|
short *dequant;
|
|
|
|
int offset;
|
|
char *eob;
|
|
|
|
union b_mode_info bmi;
|
|
} BLOCKD;
|
|
|
|
typedef void (*vp8_subpix_fn_t)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
|
|
|
|
typedef struct macroblockd
|
|
{
|
|
DECLARE_ALIGNED(16, unsigned char, predictor[384]);
|
|
DECLARE_ALIGNED(16, short, qcoeff[400]);
|
|
DECLARE_ALIGNED(16, short, dqcoeff[400]);
|
|
DECLARE_ALIGNED(16, char, eobs[25]);
|
|
|
|
DECLARE_ALIGNED(16, short, dequant_y1[16]);
|
|
DECLARE_ALIGNED(16, short, dequant_y1_dc[16]);
|
|
DECLARE_ALIGNED(16, short, dequant_y2[16]);
|
|
DECLARE_ALIGNED(16, short, dequant_uv[16]);
|
|
|
|
/* 16 Y blocks, 4 U, 4 V, 1 DC 2nd order block, each with 16 entries. */
|
|
BLOCKD block[25];
|
|
int fullpixel_mask;
|
|
|
|
YV12_BUFFER_CONFIG pre; /* Filtered copy of previous frame reconstruction */
|
|
YV12_BUFFER_CONFIG dst;
|
|
|
|
MODE_INFO *mode_info_context;
|
|
int mode_info_stride;
|
|
|
|
FRAME_TYPE frame_type;
|
|
|
|
int up_available;
|
|
int left_available;
|
|
|
|
unsigned char *recon_above[3];
|
|
unsigned char *recon_left[3];
|
|
int recon_left_stride[2];
|
|
|
|
/* Y,U,V,Y2 */
|
|
ENTROPY_CONTEXT_PLANES *above_context;
|
|
ENTROPY_CONTEXT_PLANES *left_context;
|
|
|
|
/* 0 indicates segmentation at MB level is not enabled. Otherwise the individual bits indicate which features are active. */
|
|
unsigned char segmentation_enabled;
|
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation map. */
|
|
unsigned char update_mb_segmentation_map;
|
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
|
|
unsigned char update_mb_segmentation_data;
|
|
|
|
/* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
|
|
unsigned char mb_segement_abs_delta;
|
|
|
|
/* 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 */
|
|
vp8_prob mb_segment_tree_probs[MB_FEATURE_TREE_PROBS]; /* Probability Tree used to code Segment number */
|
|
|
|
signed char segment_feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS]; /* Segment parameters */
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
vp8_subpix_fn_t subpixel_predict;
|
|
vp8_subpix_fn_t subpixel_predict8x4;
|
|
vp8_subpix_fn_t subpixel_predict8x8;
|
|
vp8_subpix_fn_t subpixel_predict16x16;
|
|
|
|
void *current_bc;
|
|
|
|
int corrupted;
|
|
|
|
#if ARCH_X86 || ARCH_X86_64
|
|
/* This is an intermediate buffer currently used in sub-pixel motion search
|
|
* to keep a copy of the reference area. This buffer can be used for other
|
|
* purpose.
|
|
*/
|
|
DECLARE_ALIGNED(32, unsigned char, y_buf[22*32]);
|
|
#endif
|
|
} MACROBLOCKD;
|
|
|
|
|
|
extern void vp8_build_block_doffsets(MACROBLOCKD *x);
|
|
extern void vp8_setup_block_dptrs(MACROBLOCKD *x);
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // VP8_COMMON_BLOCKD_H_
|