vp9_block.h revision 5ae7ac49f08a179e4f054d99fcfc9dce78d26e58 
1/*
2 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#ifndef VP9_ENCODER_VP9_BLOCK_H_
12#define VP9_ENCODER_VP9_BLOCK_H_
13
14#include "vp9/common/vp9_onyx.h"
15#include "vp9/common/vp9_entropymv.h"
16#include "vp9/common/vp9_entropy.h"
17#include "vpx_ports/mem.h"
18#include "vp9/common/vp9_onyxc_int.h"
19
20// motion search site
21typedef struct {
22  MV mv;
23  int offset;
24} search_site;
25
26// Structure to hold snapshot of coding context during the mode picking process
27typedef struct {
28  MODE_INFO mic;
29  uint8_t *zcoeff_blk;
30  int num_4x4_blk;
31  int skip;
32  int_mv best_ref_mv;
33  int_mv second_best_ref_mv;
34  int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
35  int rate;
36  int distortion;
37  int64_t intra_error;
38  int best_mode_index;
39  int rddiv;
40  int rdmult;
41  int hybrid_pred_diff;
42  int comp_pred_diff;
43  int single_pred_diff;
44  int64_t tx_rd_diff[TX_MODES];
45  int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
46
47  // motion vector cache for adaptive motion search control in partition
48  // search loop
49  int_mv pred_mv[MAX_REF_FRAMES];
50
51  // Bit flag for each mode whether it has high error in comparison to others.
52  unsigned int modes_with_high_error;
53
54  // Bit flag for each ref frame whether it has high error compared to others.
55  unsigned int frames_with_high_error;
56} PICK_MODE_CONTEXT;
57
58struct macroblock_plane {
59  DECLARE_ALIGNED(16, int16_t, src_diff[64 * 64]);
60  DECLARE_ALIGNED(16, int16_t, coeff[64 * 64]);
61  struct buf_2d src;
62
63  // Quantizer setings
64  int16_t *quant;
65  int16_t *quant_shift;
66  int16_t *zbin;
67  int16_t *round;
68
69  // Zbin Over Quant value
70  int16_t zbin_extra;
71};
72
73/* The [2] dimension is for whether we skip the EOB node (i.e. if previous
74 * coefficient in this block was zero) or not. */
75typedef unsigned int vp9_coeff_cost[BLOCK_TYPES][REF_TYPES][COEF_BANDS][2]
76                                   [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
77
78typedef struct macroblock MACROBLOCK;
79struct macroblock {
80  struct macroblock_plane plane[MAX_MB_PLANE];
81
82  MACROBLOCKD e_mbd;
83  int skip_block;
84
85  search_site *ss;
86  int ss_count;
87  int searches_per_step;
88
89  int errorperbit;
90  int sadperbit16;
91  int sadperbit4;
92  int rddiv;
93  int rdmult;
94  unsigned int mb_energy;
95  unsigned int *mb_activity_ptr;
96  int *mb_norm_activity_ptr;
97  signed int act_zbin_adj;
98
99  int mv_best_ref_index[MAX_REF_FRAMES];
100  unsigned int max_mv_context[MAX_REF_FRAMES];
101  unsigned int source_variance;
102
103  int nmvjointcost[MV_JOINTS];
104  int nmvcosts[2][MV_VALS];
105  int *nmvcost[2];
106  int nmvcosts_hp[2][MV_VALS];
107  int *nmvcost_hp[2];
108  int **mvcost;
109
110  int nmvjointsadcost[MV_JOINTS];
111  int nmvsadcosts[2][MV_VALS];
112  int *nmvsadcost[2];
113  int nmvsadcosts_hp[2][MV_VALS];
114  int *nmvsadcost_hp[2];
115  int **mvsadcost;
116
117  int mbmode_cost[MB_MODE_COUNT];
118  unsigned inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
119  int intra_uv_mode_cost[2][MB_MODE_COUNT];
120  int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
121  int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
122
123  // These define limits to motion vector components to prevent them
124  // from extending outside the UMV borders
125  int mv_col_min;
126  int mv_col_max;
127  int mv_row_min;
128  int mv_row_max;
129
130  uint8_t zcoeff_blk[TX_SIZES][256];
131  int skip;
132
133  int encode_breakout;
134
135  unsigned char *active_ptr;
136
137  // note that token_costs is the cost when eob node is skipped
138  vp9_coeff_cost token_costs[TX_SIZES];
139  DECLARE_ALIGNED(16, uint8_t, token_cache[1024]);
140
141  int optimize;
142
143  // indicate if it is in the rd search loop or encoding process
144  int use_lp32x32fdct;
145  int skip_encode;
146
147  // Used to store sub partition's choices.
148  int fast_ms;
149  int_mv pred_mv[MAX_REF_FRAMES];
150  int subblock_ref;
151
152  // TODO(jingning): Need to refactor the structure arrays that buffers the
153  // coding mode decisions of each partition type.
154  PICK_MODE_CONTEXT ab4x4_context[4][4][4];
155  PICK_MODE_CONTEXT sb8x4_context[4][4][4];
156  PICK_MODE_CONTEXT sb4x8_context[4][4][4];
157  PICK_MODE_CONTEXT sb8x8_context[4][4][4];
158  PICK_MODE_CONTEXT sb8x16_context[4][4][2];
159  PICK_MODE_CONTEXT sb16x8_context[4][4][2];
160  PICK_MODE_CONTEXT mb_context[4][4];
161  PICK_MODE_CONTEXT sb32x16_context[4][2];
162  PICK_MODE_CONTEXT sb16x32_context[4][2];
163  // when 4 MBs share coding parameters:
164  PICK_MODE_CONTEXT sb32_context[4];
165  PICK_MODE_CONTEXT sb32x64_context[2];
166  PICK_MODE_CONTEXT sb64x32_context[2];
167  PICK_MODE_CONTEXT sb64_context;
168  int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES];
169
170  BLOCK_SIZE b_partitioning[4][4][4];
171  BLOCK_SIZE mb_partitioning[4][4];
172  BLOCK_SIZE sb_partitioning[4];
173  BLOCK_SIZE sb64_partitioning;
174
175  void (*fwd_txm4x4)(const int16_t *input, int16_t *output, int stride);
176};
177
178// TODO(jingning): the variables used here are little complicated. need further
179// refactoring on organizing the temporary buffers, when recursive
180// partition down to 4x4 block size is enabled.
181static PICK_MODE_CONTEXT *get_block_context(MACROBLOCK *x, BLOCK_SIZE bsize) {
182  MACROBLOCKD *const xd = &x->e_mbd;
183
184  switch (bsize) {
185    case BLOCK_64X64:
186      return &x->sb64_context;
187    case BLOCK_64X32:
188      return &x->sb64x32_context[xd->sb_index];
189    case BLOCK_32X64:
190      return &x->sb32x64_context[xd->sb_index];
191    case BLOCK_32X32:
192      return &x->sb32_context[xd->sb_index];
193    case BLOCK_32X16:
194      return &x->sb32x16_context[xd->sb_index][xd->mb_index];
195    case BLOCK_16X32:
196      return &x->sb16x32_context[xd->sb_index][xd->mb_index];
197    case BLOCK_16X16:
198      return &x->mb_context[xd->sb_index][xd->mb_index];
199    case BLOCK_16X8:
200      return &x->sb16x8_context[xd->sb_index][xd->mb_index][xd->b_index];
201    case BLOCK_8X16:
202      return &x->sb8x16_context[xd->sb_index][xd->mb_index][xd->b_index];
203    case BLOCK_8X8:
204      return &x->sb8x8_context[xd->sb_index][xd->mb_index][xd->b_index];
205    case BLOCK_8X4:
206      return &x->sb8x4_context[xd->sb_index][xd->mb_index][xd->b_index];
207    case BLOCK_4X8:
208      return &x->sb4x8_context[xd->sb_index][xd->mb_index][xd->b_index];
209    case BLOCK_4X4:
210      return &x->ab4x4_context[xd->sb_index][xd->mb_index][xd->b_index];
211    default:
212      assert(0);
213      return NULL;
214  }
215}
216
217struct rdcost_block_args {
218  MACROBLOCK *x;
219  ENTROPY_CONTEXT t_above[16];
220  ENTROPY_CONTEXT t_left[16];
221  TX_SIZE tx_size;
222  int bw;
223  int bh;
224  int rate;
225  int64_t dist;
226  int64_t sse;
227  int this_rate;
228  int64_t this_dist;
229  int64_t this_sse;
230  int64_t this_rd;
231  int64_t best_rd;
232  int skip;
233  const int16_t *scan, *nb;
234};
235
236#endif  // VP9_ENCODER_VP9_BLOCK_H_
237