Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(118)

Side by Side Diff: source/libvpx/vp9/encoder/vp9_rdopt.c

Issue 592203002: libvpx: Pull from upstream (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « source/libvpx/vp9/encoder/vp9_rd.c ('k') | source/libvpx/vp9/encoder/vp9_sad.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 23 matching lines...) Expand all
34 #include "vp9/encoder/vp9_mcomp.h" 34 #include "vp9/encoder/vp9_mcomp.h"
35 #include "vp9/encoder/vp9_quantize.h" 35 #include "vp9/encoder/vp9_quantize.h"
36 #include "vp9/encoder/vp9_ratectrl.h" 36 #include "vp9/encoder/vp9_ratectrl.h"
37 #include "vp9/encoder/vp9_rd.h" 37 #include "vp9/encoder/vp9_rd.h"
38 #include "vp9/encoder/vp9_rdopt.h" 38 #include "vp9/encoder/vp9_rdopt.h"
39 #include "vp9/encoder/vp9_variance.h" 39 #include "vp9/encoder/vp9_variance.h"
40 40
41 #define RD_THRESH_MAX_FACT 64 41 #define RD_THRESH_MAX_FACT 64
42 #define RD_THRESH_INC 1 42 #define RD_THRESH_INC 1
43 43
44 #define LAST_FRAME_MODE_MASK 0xFFEDCD60 44 #define LAST_FRAME_MODE_MASK ((1 << GOLDEN_FRAME) | (1 << ALTREF_FRAME) | \
45 #define GOLDEN_FRAME_MODE_MASK 0xFFDA3BB0 45 (1 << INTRA_FRAME))
46 #define ALT_REF_MODE_MASK 0xFFC648D0 46 #define GOLDEN_FRAME_MODE_MASK ((1 << LAST_FRAME) | (1 << ALTREF_FRAME) | \
47 (1 << INTRA_FRAME))
48 #define ALT_REF_MODE_MASK ((1 << LAST_FRAME) | (1 << GOLDEN_FRAME) | \
49 (1 << INTRA_FRAME))
50
51 #define SECOND_REF_FRAME_MASK ((1 << ALTREF_FRAME) | 0x01)
47 52
48 #define MIN_EARLY_TERM_INDEX 3 53 #define MIN_EARLY_TERM_INDEX 3
49 54
50 typedef struct { 55 typedef struct {
51 PREDICTION_MODE mode; 56 PREDICTION_MODE mode;
52 MV_REFERENCE_FRAME ref_frame[2]; 57 MV_REFERENCE_FRAME ref_frame[2];
53 } MODE_DEFINITION; 58 } MODE_DEFINITION;
54 59
55 typedef struct { 60 typedef struct {
56 MV_REFERENCE_FRAME ref_frame[2]; 61 MV_REFERENCE_FRAME ref_frame[2];
(...skipping 22 matching lines...) Expand all
79 {NEARESTMV, {GOLDEN_FRAME, NONE}}, 84 {NEARESTMV, {GOLDEN_FRAME, NONE}},
80 85
81 {DC_PRED, {INTRA_FRAME, NONE}}, 86 {DC_PRED, {INTRA_FRAME, NONE}},
82 87
83 {NEWMV, {LAST_FRAME, NONE}}, 88 {NEWMV, {LAST_FRAME, NONE}},
84 {NEWMV, {ALTREF_FRAME, NONE}}, 89 {NEWMV, {ALTREF_FRAME, NONE}},
85 {NEWMV, {GOLDEN_FRAME, NONE}}, 90 {NEWMV, {GOLDEN_FRAME, NONE}},
86 91
87 {NEARMV, {LAST_FRAME, NONE}}, 92 {NEARMV, {LAST_FRAME, NONE}},
88 {NEARMV, {ALTREF_FRAME, NONE}}, 93 {NEARMV, {ALTREF_FRAME, NONE}},
94 {NEARMV, {GOLDEN_FRAME, NONE}},
95
96 {ZEROMV, {LAST_FRAME, NONE}},
97 {ZEROMV, {GOLDEN_FRAME, NONE}},
98 {ZEROMV, {ALTREF_FRAME, NONE}},
99
89 {NEARESTMV, {LAST_FRAME, ALTREF_FRAME}}, 100 {NEARESTMV, {LAST_FRAME, ALTREF_FRAME}},
90 {NEARESTMV, {GOLDEN_FRAME, ALTREF_FRAME}}, 101 {NEARESTMV, {GOLDEN_FRAME, ALTREF_FRAME}},
91 102
92 {TM_PRED, {INTRA_FRAME, NONE}}, 103 {TM_PRED, {INTRA_FRAME, NONE}},
93 104
94 {NEARMV, {LAST_FRAME, ALTREF_FRAME}}, 105 {NEARMV, {LAST_FRAME, ALTREF_FRAME}},
95 {NEWMV, {LAST_FRAME, ALTREF_FRAME}}, 106 {NEWMV, {LAST_FRAME, ALTREF_FRAME}},
96 {NEARMV, {GOLDEN_FRAME, NONE}},
97 {NEARMV, {GOLDEN_FRAME, ALTREF_FRAME}}, 107 {NEARMV, {GOLDEN_FRAME, ALTREF_FRAME}},
98 {NEWMV, {GOLDEN_FRAME, ALTREF_FRAME}}, 108 {NEWMV, {GOLDEN_FRAME, ALTREF_FRAME}},
99 109
100 {ZEROMV, {LAST_FRAME, NONE}},
101 {ZEROMV, {GOLDEN_FRAME, NONE}},
102 {ZEROMV, {ALTREF_FRAME, NONE}},
103 {ZEROMV, {LAST_FRAME, ALTREF_FRAME}}, 110 {ZEROMV, {LAST_FRAME, ALTREF_FRAME}},
104 {ZEROMV, {GOLDEN_FRAME, ALTREF_FRAME}}, 111 {ZEROMV, {GOLDEN_FRAME, ALTREF_FRAME}},
105 112
106 {H_PRED, {INTRA_FRAME, NONE}}, 113 {H_PRED, {INTRA_FRAME, NONE}},
107 {V_PRED, {INTRA_FRAME, NONE}}, 114 {V_PRED, {INTRA_FRAME, NONE}},
108 {D135_PRED, {INTRA_FRAME, NONE}}, 115 {D135_PRED, {INTRA_FRAME, NONE}},
109 {D207_PRED, {INTRA_FRAME, NONE}}, 116 {D207_PRED, {INTRA_FRAME, NONE}},
110 {D153_PRED, {INTRA_FRAME, NONE}}, 117 {D153_PRED, {INTRA_FRAME, NONE}},
111 {D63_PRED, {INTRA_FRAME, NONE}}, 118 {D63_PRED, {INTRA_FRAME, NONE}},
112 {D117_PRED, {INTRA_FRAME, NONE}}, 119 {D117_PRED, {INTRA_FRAME, NONE}},
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
162 169
163 static void model_rd_for_sb(VP9_COMP *cpi, BLOCK_SIZE bsize, 170 static void model_rd_for_sb(VP9_COMP *cpi, BLOCK_SIZE bsize,
164 MACROBLOCK *x, MACROBLOCKD *xd, 171 MACROBLOCK *x, MACROBLOCKD *xd,
165 int *out_rate_sum, int64_t *out_dist_sum) { 172 int *out_rate_sum, int64_t *out_dist_sum) {
166 // Note our transform coeffs are 8 times an orthogonal transform. 173 // Note our transform coeffs are 8 times an orthogonal transform.
167 // Hence quantizer step is also 8 times. To get effective quantizer 174 // Hence quantizer step is also 8 times. To get effective quantizer
168 // we need to divide by 8 before sending to modeling function. 175 // we need to divide by 8 before sending to modeling function.
169 int i; 176 int i;
170 int64_t rate_sum = 0; 177 int64_t rate_sum = 0;
171 int64_t dist_sum = 0; 178 int64_t dist_sum = 0;
172 const int ref = xd->mi[0]->mbmi.ref_frame[0]; 179 const int ref = xd->mi[0].src_mi->mbmi.ref_frame[0];
173 unsigned int sse; 180 unsigned int sse;
174 unsigned int var = 0; 181 unsigned int var = 0;
175 unsigned int sum_sse = 0; 182 unsigned int sum_sse = 0;
176 const int shift = 8; 183 const int shift = 8;
177 int rate; 184 int rate;
178 int64_t dist; 185 int64_t dist;
179 186
180 x->pred_sse[ref] = 0; 187 x->pred_sse[ref] = 0;
181 188
182 for (i = 0; i < MAX_MB_PLANE; ++i) { 189 for (i = 0; i < MAX_MB_PLANE; ++i) {
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
237 pd->dequant[1] >> 3, &rate, &dist); 244 pd->dequant[1] >> 3, &rate, &dist);
238 rate_sum += rate; 245 rate_sum += rate;
239 dist_sum += dist; 246 dist_sum += dist;
240 } 247 }
241 } 248 }
242 249
243 *out_rate_sum = (int)rate_sum; 250 *out_rate_sum = (int)rate_sum;
244 *out_dist_sum = dist_sum << 4; 251 *out_dist_sum = dist_sum << 4;
245 } 252 }
246 253
247 int64_t vp9_block_error_c(const int16_t *coeff, const int16_t *dqcoeff, 254 int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff,
248 intptr_t block_size, int64_t *ssz) { 255 intptr_t block_size, int64_t *ssz) {
249 int i; 256 int i;
250 int64_t error = 0, sqcoeff = 0; 257 int64_t error = 0, sqcoeff = 0;
251 258
252 for (i = 0; i < block_size; i++) { 259 for (i = 0; i < block_size; i++) {
253 const int diff = coeff[i] - dqcoeff[i]; 260 const int diff = coeff[i] - dqcoeff[i];
254 error += diff * diff; 261 error += diff * diff;
255 sqcoeff += coeff[i] * coeff[i]; 262 sqcoeff += coeff[i] * coeff[i];
256 } 263 }
257 264
(...skipping 12 matching lines...) Expand all
270 { 1, 2, 3, 4, 11, 256 - 21, 0 }, 277 { 1, 2, 3, 4, 11, 256 - 21, 0 },
271 { 1, 2, 3, 4, 11, 1024 - 21, 0 }, 278 { 1, 2, 3, 4, 11, 1024 - 21, 0 },
272 }; 279 };
273 static INLINE int cost_coeffs(MACROBLOCK *x, 280 static INLINE int cost_coeffs(MACROBLOCK *x,
274 int plane, int block, 281 int plane, int block,
275 ENTROPY_CONTEXT *A, ENTROPY_CONTEXT *L, 282 ENTROPY_CONTEXT *A, ENTROPY_CONTEXT *L,
276 TX_SIZE tx_size, 283 TX_SIZE tx_size,
277 const int16_t *scan, const int16_t *nb, 284 const int16_t *scan, const int16_t *nb,
278 int use_fast_coef_costing) { 285 int use_fast_coef_costing) {
279 MACROBLOCKD *const xd = &x->e_mbd; 286 MACROBLOCKD *const xd = &x->e_mbd;
280 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 287 MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
281 const struct macroblock_plane *p = &x->plane[plane]; 288 const struct macroblock_plane *p = &x->plane[plane];
282 const struct macroblockd_plane *pd = &xd->plane[plane]; 289 const struct macroblockd_plane *pd = &xd->plane[plane];
283 const PLANE_TYPE type = pd->plane_type; 290 const PLANE_TYPE type = pd->plane_type;
284 const int16_t *band_count = &band_counts[tx_size][1]; 291 const int16_t *band_count = &band_counts[tx_size][1];
285 const int eob = p->eobs[block]; 292 const int eob = p->eobs[block];
286 const int16_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); 293 const tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
287 unsigned int (*token_costs)[2][COEFF_CONTEXTS][ENTROPY_TOKENS] = 294 unsigned int (*token_costs)[2][COEFF_CONTEXTS][ENTROPY_TOKENS] =
288 x->token_costs[tx_size][type][is_inter_block(mbmi)]; 295 x->token_costs[tx_size][type][is_inter_block(mbmi)];
289 uint8_t token_cache[32 * 32]; 296 uint8_t token_cache[32 * 32];
290 int pt = combine_entropy_contexts(*A, *L); 297 int pt = combine_entropy_contexts(*A, *L);
291 int c, cost; 298 int c, cost;
292 // Check for consistency of tx_size with mode info 299 // Check for consistency of tx_size with mode info
293 assert(type == PLANE_TYPE_Y ? mbmi->tx_size == tx_size 300 assert(type == PLANE_TYPE_Y ? mbmi->tx_size == tx_size
294 : get_uv_tx_size(mbmi, pd) == tx_size); 301 : get_uv_tx_size(mbmi, pd) == tx_size);
295 302
296 if (eob == 0) { 303 if (eob == 0) {
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
346 } 353 }
347 static void dist_block(int plane, int block, TX_SIZE tx_size, 354 static void dist_block(int plane, int block, TX_SIZE tx_size,
348 struct rdcost_block_args* args) { 355 struct rdcost_block_args* args) {
349 const int ss_txfrm_size = tx_size << 1; 356 const int ss_txfrm_size = tx_size << 1;
350 MACROBLOCK* const x = args->x; 357 MACROBLOCK* const x = args->x;
351 MACROBLOCKD* const xd = &x->e_mbd; 358 MACROBLOCKD* const xd = &x->e_mbd;
352 const struct macroblock_plane *const p = &x->plane[plane]; 359 const struct macroblock_plane *const p = &x->plane[plane];
353 const struct macroblockd_plane *const pd = &xd->plane[plane]; 360 const struct macroblockd_plane *const pd = &xd->plane[plane];
354 int64_t this_sse; 361 int64_t this_sse;
355 int shift = tx_size == TX_32X32 ? 0 : 2; 362 int shift = tx_size == TX_32X32 ? 0 : 2;
356 int16_t *const coeff = BLOCK_OFFSET(p->coeff, block); 363 tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
357 int16_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); 364 tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
358 args->dist = vp9_block_error(coeff, dqcoeff, 16 << ss_txfrm_size, 365 args->dist = vp9_block_error(coeff, dqcoeff, 16 << ss_txfrm_size,
359 &this_sse) >> shift; 366 &this_sse) >> shift;
360 args->sse = this_sse >> shift; 367 args->sse = this_sse >> shift;
361 368
362 if (x->skip_encode && !is_inter_block(&xd->mi[0]->mbmi)) { 369 if (x->skip_encode && !is_inter_block(&xd->mi[0].src_mi->mbmi)) {
363 // TODO(jingning): tune the model to better capture the distortion. 370 // TODO(jingning): tune the model to better capture the distortion.
364 int64_t p = (pd->dequant[1] * pd->dequant[1] * 371 int64_t p = (pd->dequant[1] * pd->dequant[1] *
365 (1 << ss_txfrm_size)) >> (shift + 2); 372 (1 << ss_txfrm_size)) >> (shift + 2);
366 args->dist += (p >> 4); 373 args->dist += (p >> 4);
367 args->sse += p; 374 args->sse += p;
368 } 375 }
369 } 376 }
370 377
371 static void rate_block(int plane, int block, BLOCK_SIZE plane_bsize, 378 static void rate_block(int plane, int block, BLOCK_SIZE plane_bsize,
372 TX_SIZE tx_size, struct rdcost_block_args* args) { 379 TX_SIZE tx_size, struct rdcost_block_args* args) {
373 int x_idx, y_idx; 380 int x_idx, y_idx;
374 txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x_idx, &y_idx); 381 txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x_idx, &y_idx);
375 382
376 args->rate = cost_coeffs(args->x, plane, block, args->t_above + x_idx, 383 args->rate = cost_coeffs(args->x, plane, block, args->t_above + x_idx,
377 args->t_left + y_idx, tx_size, 384 args->t_left + y_idx, tx_size,
378 args->so->scan, args->so->neighbors, 385 args->so->scan, args->so->neighbors,
379 args->use_fast_coef_costing); 386 args->use_fast_coef_costing);
380 } 387 }
381 388
382 static void block_rd_txfm(int plane, int block, BLOCK_SIZE plane_bsize, 389 static void block_rd_txfm(int plane, int block, BLOCK_SIZE plane_bsize,
383 TX_SIZE tx_size, void *arg) { 390 TX_SIZE tx_size, void *arg) {
384 struct rdcost_block_args *args = arg; 391 struct rdcost_block_args *args = arg;
385 MACROBLOCK *const x = args->x; 392 MACROBLOCK *const x = args->x;
386 MACROBLOCKD *const xd = &x->e_mbd; 393 MACROBLOCKD *const xd = &x->e_mbd;
387 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 394 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
388 int64_t rd1, rd2, rd; 395 int64_t rd1, rd2, rd;
389 396
390 if (args->skip) 397 if (args->skip)
391 return; 398 return;
392 399
393 if (!is_inter_block(mbmi)) { 400 if (!is_inter_block(mbmi)) {
394 vp9_encode_block_intra(x, plane, block, plane_bsize, tx_size, &mbmi->skip); 401 vp9_encode_block_intra(x, plane, block, plane_bsize, tx_size, &mbmi->skip);
395 dist_block(plane, block, tx_size, args); 402 dist_block(plane, block, tx_size, args);
396 } else if (max_txsize_lookup[plane_bsize] == tx_size) { 403 } else if (max_txsize_lookup[plane_bsize] == tx_size) {
397 if (x->skip_txfm[(plane << 2) + (block >> (tx_size << 1))] == 0) { 404 if (x->skip_txfm[(plane << 2) + (block >> (tx_size << 1))] == 0) {
398 // full forward transform and quantization 405 // full forward transform and quantization
399 vp9_xform_quant(x, plane, block, plane_bsize, tx_size); 406 vp9_xform_quant(x, plane, block, plane_bsize, tx_size);
400 dist_block(plane, block, tx_size, args); 407 dist_block(plane, block, tx_size, args);
401 } else if (x->skip_txfm[(plane << 2) + (block >> (tx_size << 1))] == 2) { 408 } else if (x->skip_txfm[(plane << 2) + (block >> (tx_size << 1))] == 2) {
402 // compute DC coefficient 409 // compute DC coefficient
403 int16_t *const coeff = BLOCK_OFFSET(x->plane[plane].coeff, block); 410 tran_low_t *const coeff = BLOCK_OFFSET(x->plane[plane].coeff, block);
404 int16_t *const dqcoeff = BLOCK_OFFSET(xd->plane[plane].dqcoeff, block); 411 tran_low_t *const dqcoeff = BLOCK_OFFSET(xd->plane[plane].dqcoeff, block);
405 vp9_xform_quant_dc(x, plane, block, plane_bsize, tx_size); 412 vp9_xform_quant_dc(x, plane, block, plane_bsize, tx_size);
406 args->sse = x->bsse[(plane << 2) + (block >> (tx_size << 1))] << 4; 413 args->sse = x->bsse[(plane << 2) + (block >> (tx_size << 1))] << 4;
407 args->dist = args->sse; 414 args->dist = args->sse;
408 if (!x->plane[plane].eobs[block]) 415 if (!x->plane[plane].eobs[block])
409 args->dist = args->sse - ((coeff[0] * coeff[0] - 416 args->dist = args->sse - ((coeff[0] * coeff[0] -
410 (coeff[0] - dqcoeff[0]) * (coeff[0] - dqcoeff[0])) >> 2); 417 (coeff[0] - dqcoeff[0]) * (coeff[0] - dqcoeff[0])) >> 2);
411 } else { 418 } else {
412 // skip forward transform 419 // skip forward transform
413 x->plane[plane].eobs[block] = 0; 420 x->plane[plane].eobs[block] = 0;
414 args->sse = x->bsse[(plane << 2) + (block >> (tx_size << 1))] << 4; 421 args->sse = x->bsse[(plane << 2) + (block >> (tx_size << 1))] << 4;
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
449 int use_fast_coef_casting) { 456 int use_fast_coef_casting) {
450 MACROBLOCKD *const xd = &x->e_mbd; 457 MACROBLOCKD *const xd = &x->e_mbd;
451 const struct macroblockd_plane *const pd = &xd->plane[plane]; 458 const struct macroblockd_plane *const pd = &xd->plane[plane];
452 struct rdcost_block_args args; 459 struct rdcost_block_args args;
453 vp9_zero(args); 460 vp9_zero(args);
454 args.x = x; 461 args.x = x;
455 args.best_rd = ref_best_rd; 462 args.best_rd = ref_best_rd;
456 args.use_fast_coef_costing = use_fast_coef_casting; 463 args.use_fast_coef_costing = use_fast_coef_casting;
457 464
458 if (plane == 0) 465 if (plane == 0)
459 xd->mi[0]->mbmi.tx_size = tx_size; 466 xd->mi[0].src_mi->mbmi.tx_size = tx_size;
460 467
461 vp9_get_entropy_contexts(bsize, tx_size, pd, args.t_above, args.t_left); 468 vp9_get_entropy_contexts(bsize, tx_size, pd, args.t_above, args.t_left);
462 469
463 args.so = get_scan(xd, tx_size, pd->plane_type, 0); 470 args.so = get_scan(xd, tx_size, pd->plane_type, 0);
464 471
465 vp9_foreach_transformed_block_in_plane(xd, bsize, plane, 472 vp9_foreach_transformed_block_in_plane(xd, bsize, plane,
466 block_rd_txfm, &args); 473 block_rd_txfm, &args);
467 if (args.skip) { 474 if (args.skip) {
468 *rate = INT_MAX; 475 *rate = INT_MAX;
469 *distortion = INT64_MAX; 476 *distortion = INT64_MAX;
470 *sse = INT64_MAX; 477 *sse = INT64_MAX;
471 *skippable = 0; 478 *skippable = 0;
472 } else { 479 } else {
473 *distortion = args.this_dist; 480 *distortion = args.this_dist;
474 *rate = args.this_rate; 481 *rate = args.this_rate;
475 *sse = args.this_sse; 482 *sse = args.this_sse;
476 *skippable = vp9_is_skippable_in_plane(x, bsize, plane); 483 *skippable = vp9_is_skippable_in_plane(x, bsize, plane);
477 } 484 }
478 } 485 }
479 486
480 static void choose_largest_tx_size(VP9_COMP *cpi, MACROBLOCK *x, 487 static void choose_largest_tx_size(VP9_COMP *cpi, MACROBLOCK *x,
481 int *rate, int64_t *distortion, 488 int *rate, int64_t *distortion,
482 int *skip, int64_t *sse, 489 int *skip, int64_t *sse,
483 int64_t ref_best_rd, 490 int64_t ref_best_rd,
484 BLOCK_SIZE bs) { 491 BLOCK_SIZE bs) {
485 const TX_SIZE max_tx_size = max_txsize_lookup[bs]; 492 const TX_SIZE max_tx_size = max_txsize_lookup[bs];
486 VP9_COMMON *const cm = &cpi->common; 493 VP9_COMMON *const cm = &cpi->common;
487 const TX_SIZE largest_tx_size = tx_mode_to_biggest_tx_size[cm->tx_mode]; 494 const TX_SIZE largest_tx_size = tx_mode_to_biggest_tx_size[cm->tx_mode];
488 MACROBLOCKD *const xd = &x->e_mbd; 495 MACROBLOCKD *const xd = &x->e_mbd;
489 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 496 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
490 497
491 mbmi->tx_size = MIN(max_tx_size, largest_tx_size); 498 mbmi->tx_size = MIN(max_tx_size, largest_tx_size);
492 499
493 txfm_rd_in_plane(x, rate, distortion, skip, 500 txfm_rd_in_plane(x, rate, distortion, skip,
494 sse, ref_best_rd, 0, bs, 501 sse, ref_best_rd, 0, bs,
495 mbmi->tx_size, cpi->sf.use_fast_coef_costing); 502 mbmi->tx_size, cpi->sf.use_fast_coef_costing);
496 } 503 }
497 504
498 static void choose_tx_size_from_rd(VP9_COMP *cpi, MACROBLOCK *x, 505 static void choose_tx_size_from_rd(VP9_COMP *cpi, MACROBLOCK *x,
499 int *rate, 506 int *rate,
500 int64_t *distortion, 507 int64_t *distortion,
501 int *skip, 508 int *skip,
502 int64_t *psse, 509 int64_t *psse,
503 int64_t tx_cache[TX_MODES], 510 int64_t tx_cache[TX_MODES],
504 int64_t ref_best_rd, 511 int64_t ref_best_rd,
505 BLOCK_SIZE bs) { 512 BLOCK_SIZE bs) {
506 const TX_SIZE max_tx_size = max_txsize_lookup[bs]; 513 const TX_SIZE max_tx_size = max_txsize_lookup[bs];
507 VP9_COMMON *const cm = &cpi->common; 514 VP9_COMMON *const cm = &cpi->common;
508 MACROBLOCKD *const xd = &x->e_mbd; 515 MACROBLOCKD *const xd = &x->e_mbd;
509 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 516 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
510 vp9_prob skip_prob = vp9_get_skip_prob(cm, xd); 517 vp9_prob skip_prob = vp9_get_skip_prob(cm, xd);
511 int r[TX_SIZES][2], s[TX_SIZES]; 518 int r[TX_SIZES][2], s[TX_SIZES];
512 int64_t d[TX_SIZES], sse[TX_SIZES]; 519 int64_t d[TX_SIZES], sse[TX_SIZES];
513 int64_t rd[TX_SIZES][2] = {{INT64_MAX, INT64_MAX}, 520 int64_t rd[TX_SIZES][2] = {{INT64_MAX, INT64_MAX},
514 {INT64_MAX, INT64_MAX}, 521 {INT64_MAX, INT64_MAX},
515 {INT64_MAX, INT64_MAX}, 522 {INT64_MAX, INT64_MAX},
516 {INT64_MAX, INT64_MAX}}; 523 {INT64_MAX, INT64_MAX}};
517 int n, m; 524 int n, m;
518 int s0, s1; 525 int s0, s1;
519 const TX_SIZE max_mode_tx_size = tx_mode_to_biggest_tx_size[cm->tx_mode]; 526 const TX_SIZE max_mode_tx_size = tx_mode_to_biggest_tx_size[cm->tx_mode];
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
586 593
587 static void super_block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, 594 static void super_block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate,
588 int64_t *distortion, int *skip, 595 int64_t *distortion, int *skip,
589 int64_t *psse, BLOCK_SIZE bs, 596 int64_t *psse, BLOCK_SIZE bs,
590 int64_t txfm_cache[TX_MODES], 597 int64_t txfm_cache[TX_MODES],
591 int64_t ref_best_rd) { 598 int64_t ref_best_rd) {
592 MACROBLOCKD *xd = &x->e_mbd; 599 MACROBLOCKD *xd = &x->e_mbd;
593 int64_t sse; 600 int64_t sse;
594 int64_t *ret_sse = psse ? psse : &sse; 601 int64_t *ret_sse = psse ? psse : &sse;
595 602
596 assert(bs == xd->mi[0]->mbmi.sb_type); 603 assert(bs == xd->mi[0].src_mi->mbmi.sb_type);
597 604
598 if (cpi->sf.tx_size_search_method == USE_LARGESTALL || xd->lossless) { 605 if (cpi->sf.tx_size_search_method == USE_LARGESTALL || xd->lossless) {
599 vpx_memset(txfm_cache, 0, TX_MODES * sizeof(int64_t)); 606 vpx_memset(txfm_cache, 0, TX_MODES * sizeof(int64_t));
600 choose_largest_tx_size(cpi, x, rate, distortion, skip, ret_sse, ref_best_rd, 607 choose_largest_tx_size(cpi, x, rate, distortion, skip, ret_sse, ref_best_rd,
601 bs); 608 bs);
602 } else { 609 } else {
603 choose_tx_size_from_rd(cpi, x, rate, distortion, skip, ret_sse, 610 choose_tx_size_from_rd(cpi, x, rate, distortion, skip, ret_sse,
604 txfm_cache, ref_best_rd, bs); 611 txfm_cache, ref_best_rd, bs);
605 } 612 }
606 } 613 }
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
650 657
651 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize]; 658 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
652 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize]; 659 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
653 int idx, idy; 660 int idx, idy;
654 uint8_t best_dst[8 * 8]; 661 uint8_t best_dst[8 * 8];
655 662
656 assert(ib < 4); 663 assert(ib < 4);
657 664
658 vpx_memcpy(ta, a, sizeof(ta)); 665 vpx_memcpy(ta, a, sizeof(ta));
659 vpx_memcpy(tl, l, sizeof(tl)); 666 vpx_memcpy(tl, l, sizeof(tl));
660 xd->mi[0]->mbmi.tx_size = TX_4X4; 667 xd->mi[0].src_mi->mbmi.tx_size = TX_4X4;
661 668
662 for (mode = DC_PRED; mode <= TM_PRED; ++mode) { 669 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
663 int64_t this_rd; 670 int64_t this_rd;
664 int ratey = 0; 671 int ratey = 0;
665 int64_t distortion = 0; 672 int64_t distortion = 0;
666 int rate = bmode_costs[mode]; 673 int rate = bmode_costs[mode];
667 674
668 if (!(cpi->sf.intra_y_mode_mask[TX_4X4] & (1 << mode))) 675 if (!(cpi->sf.intra_y_mode_mask[TX_4X4] & (1 << mode)))
669 continue; 676 continue;
670 677
671 // Only do the oblique modes if the best so far is 678 // Only do the oblique modes if the best so far is
672 // one of the neighboring directional modes 679 // one of the neighboring directional modes
673 if (cpi->sf.mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH) { 680 if (cpi->sf.mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH) {
674 if (conditional_skipintra(mode, *best_mode)) 681 if (conditional_skipintra(mode, *best_mode))
675 continue; 682 continue;
676 } 683 }
677 684
678 vpx_memcpy(tempa, ta, sizeof(ta)); 685 vpx_memcpy(tempa, ta, sizeof(ta));
679 vpx_memcpy(templ, tl, sizeof(tl)); 686 vpx_memcpy(templ, tl, sizeof(tl));
680 687
681 for (idy = 0; idy < num_4x4_blocks_high; ++idy) { 688 for (idy = 0; idy < num_4x4_blocks_high; ++idy) {
682 for (idx = 0; idx < num_4x4_blocks_wide; ++idx) { 689 for (idx = 0; idx < num_4x4_blocks_wide; ++idx) {
683 const int block = ib + idy * 2 + idx; 690 const int block = ib + idy * 2 + idx;
684 const uint8_t *const src = &src_init[idx * 4 + idy * 4 * src_stride]; 691 const uint8_t *const src = &src_init[idx * 4 + idy * 4 * src_stride];
685 uint8_t *const dst = &dst_init[idx * 4 + idy * 4 * dst_stride]; 692 uint8_t *const dst = &dst_init[idx * 4 + idy * 4 * dst_stride];
686 int16_t *const src_diff = raster_block_offset_int16(BLOCK_8X8, block, 693 int16_t *const src_diff = raster_block_offset_int16(BLOCK_8X8, block,
687 p->src_diff); 694 p->src_diff);
688 int16_t *const coeff = BLOCK_OFFSET(x->plane[0].coeff, block); 695 tran_low_t *const coeff = BLOCK_OFFSET(x->plane[0].coeff, block);
689 xd->mi[0]->bmi[block].as_mode = mode; 696 xd->mi[0].src_mi->bmi[block].as_mode = mode;
690 vp9_predict_intra_block(xd, block, 1, 697 vp9_predict_intra_block(xd, block, 1,
691 TX_4X4, mode, 698 TX_4X4, mode,
692 x->skip_encode ? src : dst, 699 x->skip_encode ? src : dst,
693 x->skip_encode ? src_stride : dst_stride, 700 x->skip_encode ? src_stride : dst_stride,
694 dst, dst_stride, idx, idy, 0); 701 dst, dst_stride, idx, idy, 0);
695 vp9_subtract_block(4, 4, src_diff, 8, src, src_stride, dst, dst_stride); 702 vp9_subtract_block(4, 4, src_diff, 8, src, src_stride, dst, dst_stride);
696 703
697 if (xd->lossless) { 704 if (xd->lossless) {
698 const scan_order *so = &vp9_default_scan_orders[TX_4X4]; 705 const scan_order *so = &vp9_default_scan_orders[TX_4X4];
699 vp9_fwht4x4(src_diff, coeff, 8); 706 vp9_fwht4x4(src_diff, coeff, 8);
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
752 759
753 return best_rd; 760 return best_rd;
754 } 761 }
755 762
756 static int64_t rd_pick_intra_sub_8x8_y_mode(VP9_COMP *cpi, MACROBLOCK *mb, 763 static int64_t rd_pick_intra_sub_8x8_y_mode(VP9_COMP *cpi, MACROBLOCK *mb,
757 int *rate, int *rate_y, 764 int *rate, int *rate_y,
758 int64_t *distortion, 765 int64_t *distortion,
759 int64_t best_rd) { 766 int64_t best_rd) {
760 int i, j; 767 int i, j;
761 const MACROBLOCKD *const xd = &mb->e_mbd; 768 const MACROBLOCKD *const xd = &mb->e_mbd;
762 MODE_INFO *const mic = xd->mi[0]; 769 MODE_INFO *const mic = xd->mi[0].src_mi;
763 const MODE_INFO *above_mi = xd->mi[-xd->mi_stride]; 770 const MODE_INFO *above_mi = xd->mi[-xd->mi_stride].src_mi;
764 const MODE_INFO *left_mi = xd->left_available ? xd->mi[-1] : NULL; 771 const MODE_INFO *left_mi = xd->left_available ? xd->mi[-1].src_mi : NULL;
765 const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; 772 const BLOCK_SIZE bsize = xd->mi[0].src_mi->mbmi.sb_type;
766 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize]; 773 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
767 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize]; 774 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
768 int idx, idy; 775 int idx, idy;
769 int cost = 0; 776 int cost = 0;
770 int64_t total_distortion = 0; 777 int64_t total_distortion = 0;
771 int tot_rate_y = 0; 778 int tot_rate_y = 0;
772 int64_t total_rd = 0; 779 int64_t total_rd = 0;
773 ENTROPY_CONTEXT t_above[4], t_left[4]; 780 ENTROPY_CONTEXT t_above[4], t_left[4];
774 const int *bmode_costs = cpi->mbmode_cost; 781 const int *bmode_costs = cpi->mbmode_cost;
775 782
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
822 829
823 static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x, 830 static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
824 int *rate, int *rate_tokenonly, 831 int *rate, int *rate_tokenonly,
825 int64_t *distortion, int *skippable, 832 int64_t *distortion, int *skippable,
826 BLOCK_SIZE bsize, 833 BLOCK_SIZE bsize,
827 int64_t tx_cache[TX_MODES], 834 int64_t tx_cache[TX_MODES],
828 int64_t best_rd) { 835 int64_t best_rd) {
829 PREDICTION_MODE mode; 836 PREDICTION_MODE mode;
830 PREDICTION_MODE mode_selected = DC_PRED; 837 PREDICTION_MODE mode_selected = DC_PRED;
831 MACROBLOCKD *const xd = &x->e_mbd; 838 MACROBLOCKD *const xd = &x->e_mbd;
832 MODE_INFO *const mic = xd->mi[0]; 839 MODE_INFO *const mic = xd->mi[0].src_mi;
833 int this_rate, this_rate_tokenonly, s; 840 int this_rate, this_rate_tokenonly, s;
834 int64_t this_distortion, this_rd; 841 int64_t this_distortion, this_rd;
835 TX_SIZE best_tx = TX_4X4; 842 TX_SIZE best_tx = TX_4X4;
836 int i; 843 int i;
837 int *bmode_costs = cpi->mbmode_cost; 844 int *bmode_costs = cpi->mbmode_cost;
838 845
839 if (cpi->sf.tx_size_search_method == USE_FULL_RD) 846 if (cpi->sf.tx_size_search_method == USE_FULL_RD)
840 for (i = 0; i < TX_MODES; i++) 847 for (i = 0; i < TX_MODES; i++)
841 tx_cache[i] = INT64_MAX; 848 tx_cache[i] = INT64_MAX;
842 849
843 /* Y Search for intra prediction mode */ 850 /* Y Search for intra prediction mode */
844 for (mode = DC_PRED; mode <= TM_PRED; mode++) { 851 for (mode = DC_PRED; mode <= TM_PRED; mode++) {
845 int64_t local_tx_cache[TX_MODES]; 852 int64_t local_tx_cache[TX_MODES];
846 MODE_INFO *above_mi = xd->mi[-xd->mi_stride]; 853 MODE_INFO *above_mi = xd->mi[-xd->mi_stride].src_mi;
847 MODE_INFO *left_mi = xd->left_available ? xd->mi[-1] : NULL; 854 MODE_INFO *left_mi = xd->left_available ? xd->mi[-1].src_mi : NULL;
848 855
849 if (cpi->common.frame_type == KEY_FRAME) { 856 if (cpi->common.frame_type == KEY_FRAME) {
850 const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0); 857 const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0);
851 const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0); 858 const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0);
852 859
853 bmode_costs = cpi->y_mode_costs[A][L]; 860 bmode_costs = cpi->y_mode_costs[A][L];
854 } 861 }
855 mic->mbmi.mode = mode; 862 mic->mbmi.mode = mode;
856 863
857 super_block_yrd(cpi, x, &this_rate_tokenonly, &this_distortion, 864 super_block_yrd(cpi, x, &this_rate_tokenonly, &this_distortion,
(...skipping 30 matching lines...) Expand all
888 mic->mbmi.tx_size = best_tx; 895 mic->mbmi.tx_size = best_tx;
889 896
890 return best_rd; 897 return best_rd;
891 } 898 }
892 899
893 static void super_block_uvrd(const VP9_COMP *cpi, MACROBLOCK *x, 900 static void super_block_uvrd(const VP9_COMP *cpi, MACROBLOCK *x,
894 int *rate, int64_t *distortion, int *skippable, 901 int *rate, int64_t *distortion, int *skippable,
895 int64_t *sse, BLOCK_SIZE bsize, 902 int64_t *sse, BLOCK_SIZE bsize,
896 int64_t ref_best_rd) { 903 int64_t ref_best_rd) {
897 MACROBLOCKD *const xd = &x->e_mbd; 904 MACROBLOCKD *const xd = &x->e_mbd;
898 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 905 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
899 const TX_SIZE uv_tx_size = get_uv_tx_size(mbmi, &xd->plane[1]); 906 const TX_SIZE uv_tx_size = get_uv_tx_size(mbmi, &xd->plane[1]);
900 int plane; 907 int plane;
901 int pnrate = 0, pnskip = 1; 908 int pnrate = 0, pnskip = 1;
902 int64_t pndist = 0, pnsse = 0; 909 int64_t pndist = 0, pnsse = 0;
903 910
904 if (ref_best_rd < 0) 911 if (ref_best_rd < 0)
905 goto term; 912 goto term;
906 913
907 if (is_inter_block(mbmi)) { 914 if (is_inter_block(mbmi)) {
908 int plane; 915 int plane;
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
945 PREDICTION_MODE mode; 952 PREDICTION_MODE mode;
946 PREDICTION_MODE mode_selected = DC_PRED; 953 PREDICTION_MODE mode_selected = DC_PRED;
947 int64_t best_rd = INT64_MAX, this_rd; 954 int64_t best_rd = INT64_MAX, this_rd;
948 int this_rate_tokenonly, this_rate, s; 955 int this_rate_tokenonly, this_rate, s;
949 int64_t this_distortion, this_sse; 956 int64_t this_distortion, this_sse;
950 957
951 for (mode = DC_PRED; mode <= TM_PRED; ++mode) { 958 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
952 if (!(cpi->sf.intra_uv_mode_mask[max_tx_size] & (1 << mode))) 959 if (!(cpi->sf.intra_uv_mode_mask[max_tx_size] & (1 << mode)))
953 continue; 960 continue;
954 961
955 xd->mi[0]->mbmi.uv_mode = mode; 962 xd->mi[0].src_mi->mbmi.uv_mode = mode;
956 963
957 super_block_uvrd(cpi, x, &this_rate_tokenonly, 964 super_block_uvrd(cpi, x, &this_rate_tokenonly,
958 &this_distortion, &s, &this_sse, bsize, best_rd); 965 &this_distortion, &s, &this_sse, bsize, best_rd);
959 if (this_rate_tokenonly == INT_MAX) 966 if (this_rate_tokenonly == INT_MAX)
960 continue; 967 continue;
961 this_rate = this_rate_tokenonly + 968 this_rate = this_rate_tokenonly +
962 cpi->intra_uv_mode_cost[cpi->common.frame_type][mode]; 969 cpi->intra_uv_mode_cost[cpi->common.frame_type][mode];
963 this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); 970 this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
964 971
965 if (this_rd < best_rd) { 972 if (this_rd < best_rd) {
966 mode_selected = mode; 973 mode_selected = mode;
967 best_rd = this_rd; 974 best_rd = this_rd;
968 *rate = this_rate; 975 *rate = this_rate;
969 *rate_tokenonly = this_rate_tokenonly; 976 *rate_tokenonly = this_rate_tokenonly;
970 *distortion = this_distortion; 977 *distortion = this_distortion;
971 *skippable = s; 978 *skippable = s;
972 if (!x->select_tx_size) 979 if (!x->select_tx_size)
973 swap_block_ptr(x, ctx, 2, 0, 1, MAX_MB_PLANE); 980 swap_block_ptr(x, ctx, 2, 0, 1, MAX_MB_PLANE);
974 } 981 }
975 } 982 }
976 983
977 xd->mi[0]->mbmi.uv_mode = mode_selected; 984 xd->mi[0].src_mi->mbmi.uv_mode = mode_selected;
978 return best_rd; 985 return best_rd;
979 } 986 }
980 987
981 static int64_t rd_sbuv_dcpred(const VP9_COMP *cpi, MACROBLOCK *x, 988 static int64_t rd_sbuv_dcpred(const VP9_COMP *cpi, MACROBLOCK *x,
982 int *rate, int *rate_tokenonly, 989 int *rate, int *rate_tokenonly,
983 int64_t *distortion, int *skippable, 990 int64_t *distortion, int *skippable,
984 BLOCK_SIZE bsize) { 991 BLOCK_SIZE bsize) {
985 const VP9_COMMON *cm = &cpi->common; 992 const VP9_COMMON *cm = &cpi->common;
986 int64_t unused; 993 int64_t unused;
987 994
988 x->e_mbd.mi[0]->mbmi.uv_mode = DC_PRED; 995 x->e_mbd.mi[0].src_mi->mbmi.uv_mode = DC_PRED;
989 super_block_uvrd(cpi, x, rate_tokenonly, distortion, 996 super_block_uvrd(cpi, x, rate_tokenonly, distortion,
990 skippable, &unused, bsize, INT64_MAX); 997 skippable, &unused, bsize, INT64_MAX);
991 *rate = *rate_tokenonly + cpi->intra_uv_mode_cost[cm->frame_type][DC_PRED]; 998 *rate = *rate_tokenonly + cpi->intra_uv_mode_cost[cm->frame_type][DC_PRED];
992 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion); 999 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
993 } 1000 }
994 1001
995 static void choose_intra_uv_mode(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx, 1002 static void choose_intra_uv_mode(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
996 BLOCK_SIZE bsize, TX_SIZE max_tx_size, 1003 BLOCK_SIZE bsize, TX_SIZE max_tx_size,
997 int *rate_uv, int *rate_uv_tokenonly, 1004 int *rate_uv, int *rate_uv_tokenonly,
998 int64_t *dist_uv, int *skip_uv, 1005 int64_t *dist_uv, int *skip_uv,
999 PREDICTION_MODE *mode_uv) { 1006 PREDICTION_MODE *mode_uv) {
1000 MACROBLOCK *const x = &cpi->mb; 1007 MACROBLOCK *const x = &cpi->mb;
1001 1008
1002 // Use an estimated rd for uv_intra based on DC_PRED if the 1009 // Use an estimated rd for uv_intra based on DC_PRED if the
1003 // appropriate speed flag is set. 1010 // appropriate speed flag is set.
1004 if (cpi->sf.use_uv_intra_rd_estimate) { 1011 if (cpi->sf.use_uv_intra_rd_estimate) {
1005 rd_sbuv_dcpred(cpi, x, rate_uv, rate_uv_tokenonly, dist_uv, 1012 rd_sbuv_dcpred(cpi, x, rate_uv, rate_uv_tokenonly, dist_uv,
1006 skip_uv, bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize); 1013 skip_uv, bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize);
1007 // Else do a proper rd search for each possible transform size that may 1014 // Else do a proper rd search for each possible transform size that may
1008 // be considered in the main rd loop. 1015 // be considered in the main rd loop.
1009 } else { 1016 } else {
1010 rd_pick_intra_sbuv_mode(cpi, x, ctx, 1017 rd_pick_intra_sbuv_mode(cpi, x, ctx,
1011 rate_uv, rate_uv_tokenonly, dist_uv, skip_uv, 1018 rate_uv, rate_uv_tokenonly, dist_uv, skip_uv,
1012 bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize, max_tx_size); 1019 bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize, max_tx_size);
1013 } 1020 }
1014 *mode_uv = x->e_mbd.mi[0]->mbmi.uv_mode; 1021 *mode_uv = x->e_mbd.mi[0].src_mi->mbmi.uv_mode;
1015 } 1022 }
1016 1023
1017 static int cost_mv_ref(const VP9_COMP *cpi, PREDICTION_MODE mode, 1024 static int cost_mv_ref(const VP9_COMP *cpi, PREDICTION_MODE mode,
1018 int mode_context) { 1025 int mode_context) {
1019 assert(is_inter_mode(mode)); 1026 assert(is_inter_mode(mode));
1020 return cpi->inter_mode_cost[mode_context][INTER_OFFSET(mode)]; 1027 return cpi->inter_mode_cost[mode_context][INTER_OFFSET(mode)];
1021 } 1028 }
1022 1029
1023 static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x, 1030 static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
1024 BLOCK_SIZE bsize, 1031 BLOCK_SIZE bsize,
1025 int_mv *frame_mv, 1032 int_mv *frame_mv,
1026 int mi_row, int mi_col, 1033 int mi_row, int mi_col,
1027 int_mv single_newmv[MAX_REF_FRAMES], 1034 int_mv single_newmv[MAX_REF_FRAMES],
1028 int *rate_mv); 1035 int *rate_mv);
1029 1036
1030 static int set_and_cost_bmi_mvs(VP9_COMP *cpi, MACROBLOCKD *xd, int i, 1037 static int set_and_cost_bmi_mvs(VP9_COMP *cpi, MACROBLOCKD *xd, int i,
1031 PREDICTION_MODE mode, int_mv this_mv[2], 1038 PREDICTION_MODE mode, int_mv this_mv[2],
1032 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], 1039 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES],
1033 int_mv seg_mvs[MAX_REF_FRAMES], 1040 int_mv seg_mvs[MAX_REF_FRAMES],
1034 int_mv *best_ref_mv[2], const int *mvjcost, 1041 int_mv *best_ref_mv[2], const int *mvjcost,
1035 int *mvcost[2]) { 1042 int *mvcost[2]) {
1036 MODE_INFO *const mic = xd->mi[0]; 1043 MODE_INFO *const mic = xd->mi[0].src_mi;
1037 const MB_MODE_INFO *const mbmi = &mic->mbmi; 1044 const MB_MODE_INFO *const mbmi = &mic->mbmi;
1038 int thismvcost = 0; 1045 int thismvcost = 0;
1039 int idx, idy; 1046 int idx, idy;
1040 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[mbmi->sb_type]; 1047 const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[mbmi->sb_type];
1041 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[mbmi->sb_type]; 1048 const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[mbmi->sb_type];
1042 const int is_compound = has_second_ref(mbmi); 1049 const int is_compound = has_second_ref(mbmi);
1043 1050
1044 switch (mode) { 1051 switch (mode) {
1045 case NEWMV: 1052 case NEWMV:
1046 this_mv[0].as_int = seg_mvs[mbmi->ref_frame[0]].as_int; 1053 this_mv[0].as_int = seg_mvs[mbmi->ref_frame[0]].as_int;
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
1088 int i, 1095 int i,
1089 int *labelyrate, 1096 int *labelyrate,
1090 int64_t *distortion, int64_t *sse, 1097 int64_t *distortion, int64_t *sse,
1091 ENTROPY_CONTEXT *ta, 1098 ENTROPY_CONTEXT *ta,
1092 ENTROPY_CONTEXT *tl, 1099 ENTROPY_CONTEXT *tl,
1093 int mi_row, int mi_col) { 1100 int mi_row, int mi_col) {
1094 int k; 1101 int k;
1095 MACROBLOCKD *xd = &x->e_mbd; 1102 MACROBLOCKD *xd = &x->e_mbd;
1096 struct macroblockd_plane *const pd = &xd->plane[0]; 1103 struct macroblockd_plane *const pd = &xd->plane[0];
1097 struct macroblock_plane *const p = &x->plane[0]; 1104 struct macroblock_plane *const p = &x->plane[0];
1098 MODE_INFO *const mi = xd->mi[0]; 1105 MODE_INFO *const mi = xd->mi[0].src_mi;
1099 const BLOCK_SIZE plane_bsize = get_plane_block_size(mi->mbmi.sb_type, pd); 1106 const BLOCK_SIZE plane_bsize = get_plane_block_size(mi->mbmi.sb_type, pd);
1100 const int width = 4 * num_4x4_blocks_wide_lookup[plane_bsize]; 1107 const int width = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
1101 const int height = 4 * num_4x4_blocks_high_lookup[plane_bsize]; 1108 const int height = 4 * num_4x4_blocks_high_lookup[plane_bsize];
1102 int idx, idy; 1109 int idx, idy;
1103 1110
1104 const uint8_t *const src = &p->src.buf[raster_block_offset(BLOCK_8X8, i, 1111 const uint8_t *const src = &p->src.buf[raster_block_offset(BLOCK_8X8, i,
1105 p->src.stride)]; 1112 p->src.stride)];
1106 uint8_t *const dst = &pd->dst.buf[raster_block_offset(BLOCK_8X8, i, 1113 uint8_t *const dst = &pd->dst.buf[raster_block_offset(BLOCK_8X8, i,
1107 pd->dst.stride)]; 1114 pd->dst.stride)];
1108 int64_t thisdistortion = 0, thissse = 0; 1115 int64_t thisdistortion = 0, thissse = 0;
(...skipping 16 matching lines...) Expand all
1125 1132
1126 vp9_subtract_block(height, width, 1133 vp9_subtract_block(height, width,
1127 raster_block_offset_int16(BLOCK_8X8, i, p->src_diff), 8, 1134 raster_block_offset_int16(BLOCK_8X8, i, p->src_diff), 8,
1128 src, p->src.stride, 1135 src, p->src.stride,
1129 dst, pd->dst.stride); 1136 dst, pd->dst.stride);
1130 1137
1131 k = i; 1138 k = i;
1132 for (idy = 0; idy < height / 4; ++idy) { 1139 for (idy = 0; idy < height / 4; ++idy) {
1133 for (idx = 0; idx < width / 4; ++idx) { 1140 for (idx = 0; idx < width / 4; ++idx) {
1134 int64_t ssz, rd, rd1, rd2; 1141 int64_t ssz, rd, rd1, rd2;
1135 int16_t* coeff; 1142 tran_low_t* coeff;
1136 1143
1137 k += (idy * 2 + idx); 1144 k += (idy * 2 + idx);
1138 coeff = BLOCK_OFFSET(p->coeff, k); 1145 coeff = BLOCK_OFFSET(p->coeff, k);
1139 x->fwd_txm4x4(raster_block_offset_int16(BLOCK_8X8, k, p->src_diff), 1146 x->fwd_txm4x4(raster_block_offset_int16(BLOCK_8X8, k, p->src_diff),
1140 coeff, 8); 1147 coeff, 8);
1141 vp9_regular_quantize_b_4x4(x, 0, k, so->scan, so->iscan); 1148 vp9_regular_quantize_b_4x4(x, 0, k, so->scan, so->iscan);
1142 thisdistortion += vp9_block_error(coeff, BLOCK_OFFSET(pd->dqcoeff, k), 1149 thisdistortion += vp9_block_error(coeff, BLOCK_OFFSET(pd->dqcoeff, k),
1143 16, &ssz); 1150 16, &ssz);
1144 thissse += ssz; 1151 thissse += ssz;
1145 thisrate += cost_coeffs(x, 0, k, ta + (k & 1), tl + (k >> 1), TX_4X4, 1152 thisrate += cost_coeffs(x, 0, k, ta + (k & 1), tl + (k >> 1), TX_4X4,
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
1187 } BEST_SEG_INFO; 1194 } BEST_SEG_INFO;
1188 1195
1189 static INLINE int mv_check_bounds(const MACROBLOCK *x, const MV *mv) { 1196 static INLINE int mv_check_bounds(const MACROBLOCK *x, const MV *mv) {
1190 return (mv->row >> 3) < x->mv_row_min || 1197 return (mv->row >> 3) < x->mv_row_min ||
1191 (mv->row >> 3) > x->mv_row_max || 1198 (mv->row >> 3) > x->mv_row_max ||
1192 (mv->col >> 3) < x->mv_col_min || 1199 (mv->col >> 3) < x->mv_col_min ||
1193 (mv->col >> 3) > x->mv_col_max; 1200 (mv->col >> 3) > x->mv_col_max;
1194 } 1201 }
1195 1202
1196 static INLINE void mi_buf_shift(MACROBLOCK *x, int i) { 1203 static INLINE void mi_buf_shift(MACROBLOCK *x, int i) {
1197 MB_MODE_INFO *const mbmi = &x->e_mbd.mi[0]->mbmi; 1204 MB_MODE_INFO *const mbmi = &x->e_mbd.mi[0].src_mi->mbmi;
1198 struct macroblock_plane *const p = &x->plane[0]; 1205 struct macroblock_plane *const p = &x->plane[0];
1199 struct macroblockd_plane *const pd = &x->e_mbd.plane[0]; 1206 struct macroblockd_plane *const pd = &x->e_mbd.plane[0];
1200 1207
1201 p->src.buf = &p->src.buf[raster_block_offset(BLOCK_8X8, i, p->src.stride)]; 1208 p->src.buf = &p->src.buf[raster_block_offset(BLOCK_8X8, i, p->src.stride)];
1202 assert(((intptr_t)pd->pre[0].buf & 0x7) == 0); 1209 assert(((intptr_t)pd->pre[0].buf & 0x7) == 0);
1203 pd->pre[0].buf = &pd->pre[0].buf[raster_block_offset(BLOCK_8X8, i, 1210 pd->pre[0].buf = &pd->pre[0].buf[raster_block_offset(BLOCK_8X8, i,
1204 pd->pre[0].stride)]; 1211 pd->pre[0].stride)];
1205 if (has_second_ref(mbmi)) 1212 if (has_second_ref(mbmi))
1206 pd->pre[1].buf = &pd->pre[1].buf[raster_block_offset(BLOCK_8X8, i, 1213 pd->pre[1].buf = &pd->pre[1].buf[raster_block_offset(BLOCK_8X8, i,
1207 pd->pre[1].stride)]; 1214 pd->pre[1].stride)];
1208 } 1215 }
1209 1216
1210 static INLINE void mi_buf_restore(MACROBLOCK *x, struct buf_2d orig_src, 1217 static INLINE void mi_buf_restore(MACROBLOCK *x, struct buf_2d orig_src,
1211 struct buf_2d orig_pre[2]) { 1218 struct buf_2d orig_pre[2]) {
1212 MB_MODE_INFO *mbmi = &x->e_mbd.mi[0]->mbmi; 1219 MB_MODE_INFO *mbmi = &x->e_mbd.mi[0].src_mi->mbmi;
1213 x->plane[0].src = orig_src; 1220 x->plane[0].src = orig_src;
1214 x->e_mbd.plane[0].pre[0] = orig_pre[0]; 1221 x->e_mbd.plane[0].pre[0] = orig_pre[0];
1215 if (has_second_ref(mbmi)) 1222 if (has_second_ref(mbmi))
1216 x->e_mbd.plane[0].pre[1] = orig_pre[1]; 1223 x->e_mbd.plane[0].pre[1] = orig_pre[1];
1217 } 1224 }
1218 1225
1219 static INLINE int mv_has_subpel(const MV *mv) { 1226 static INLINE int mv_has_subpel(const MV *mv) {
1220 return (mv->row & 0x0F) || (mv->col & 0x0F); 1227 return (mv->row & 0x0F) || (mv->col & 0x0F);
1221 } 1228 }
1222 1229
1223 // Check if NEARESTMV/NEARMV/ZEROMV is the cheapest way encode zero motion. 1230 // Check if NEARESTMV/NEARMV/ZEROMV is the cheapest way encode zero motion.
1224 // TODO(aconverse): Find out if this is still productive then clean up or remove 1231 // TODO(aconverse): Find out if this is still productive then clean up or remove
1225 static int check_best_zero_mv( 1232 static int check_best_zero_mv(
1226 const VP9_COMP *cpi, const uint8_t mode_context[MAX_REF_FRAMES], 1233 const VP9_COMP *cpi, const uint8_t mode_context[MAX_REF_FRAMES],
1227 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], 1234 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], int this_mode,
1228 int inter_mode_mask, int this_mode,
1229 const MV_REFERENCE_FRAME ref_frames[2]) { 1235 const MV_REFERENCE_FRAME ref_frames[2]) {
1230 if ((inter_mode_mask & (1 << ZEROMV)) && 1236 if ((this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
1231 (this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
1232 frame_mv[this_mode][ref_frames[0]].as_int == 0 && 1237 frame_mv[this_mode][ref_frames[0]].as_int == 0 &&
1233 (ref_frames[1] == NONE || 1238 (ref_frames[1] == NONE ||
1234 frame_mv[this_mode][ref_frames[1]].as_int == 0)) { 1239 frame_mv[this_mode][ref_frames[1]].as_int == 0)) {
1235 int rfc = mode_context[ref_frames[0]]; 1240 int rfc = mode_context[ref_frames[0]];
1236 int c1 = cost_mv_ref(cpi, NEARMV, rfc); 1241 int c1 = cost_mv_ref(cpi, NEARMV, rfc);
1237 int c2 = cost_mv_ref(cpi, NEARESTMV, rfc); 1242 int c2 = cost_mv_ref(cpi, NEARESTMV, rfc);
1238 int c3 = cost_mv_ref(cpi, ZEROMV, rfc); 1243 int c3 = cost_mv_ref(cpi, ZEROMV, rfc);
1239 1244
1240 if (this_mode == NEARMV) { 1245 if (this_mode == NEARMV) {
1241 if (c1 > c3) return 0; 1246 if (c1 > c3) return 0;
(...skipping 25 matching lines...) Expand all
1267 int *returnyrate, 1272 int *returnyrate,
1268 int64_t *returndistortion, 1273 int64_t *returndistortion,
1269 int *skippable, int64_t *psse, 1274 int *skippable, int64_t *psse,
1270 int mvthresh, 1275 int mvthresh,
1271 int_mv seg_mvs[4][MAX_REF_FRAMES], 1276 int_mv seg_mvs[4][MAX_REF_FRAMES],
1272 BEST_SEG_INFO *bsi_buf, int filter_idx, 1277 BEST_SEG_INFO *bsi_buf, int filter_idx,
1273 int mi_row, int mi_col) { 1278 int mi_row, int mi_col) {
1274 int i; 1279 int i;
1275 BEST_SEG_INFO *bsi = bsi_buf + filter_idx; 1280 BEST_SEG_INFO *bsi = bsi_buf + filter_idx;
1276 MACROBLOCKD *xd = &x->e_mbd; 1281 MACROBLOCKD *xd = &x->e_mbd;
1277 MODE_INFO *mi = xd->mi[0]; 1282 MODE_INFO *mi = xd->mi[0].src_mi;
1278 MB_MODE_INFO *mbmi = &mi->mbmi; 1283 MB_MODE_INFO *mbmi = &mi->mbmi;
1279 int mode_idx; 1284 int mode_idx;
1280 int k, br = 0, idx, idy; 1285 int k, br = 0, idx, idy;
1281 int64_t bd = 0, block_sse = 0; 1286 int64_t bd = 0, block_sse = 0;
1282 PREDICTION_MODE this_mode; 1287 PREDICTION_MODE this_mode;
1283 VP9_COMMON *cm = &cpi->common; 1288 VP9_COMMON *cm = &cpi->common;
1284 struct macroblock_plane *const p = &x->plane[0]; 1289 struct macroblock_plane *const p = &x->plane[0];
1285 struct macroblockd_plane *const pd = &xd->plane[0]; 1290 struct macroblockd_plane *const pd = &xd->plane[0];
1286 const int label_count = 4; 1291 const int label_count = 4;
1287 int64_t this_segment_rd = 0; 1292 int64_t this_segment_rd = 0;
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
1339 for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { 1344 for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) {
1340 const struct buf_2d orig_src = x->plane[0].src; 1345 const struct buf_2d orig_src = x->plane[0].src;
1341 struct buf_2d orig_pre[2]; 1346 struct buf_2d orig_pre[2];
1342 1347
1343 mode_idx = INTER_OFFSET(this_mode); 1348 mode_idx = INTER_OFFSET(this_mode);
1344 bsi->rdstat[i][mode_idx].brdcost = INT64_MAX; 1349 bsi->rdstat[i][mode_idx].brdcost = INT64_MAX;
1345 if (!(inter_mode_mask & (1 << this_mode))) 1350 if (!(inter_mode_mask & (1 << this_mode)))
1346 continue; 1351 continue;
1347 1352
1348 if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv, 1353 if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv,
1349 inter_mode_mask,
1350 this_mode, mbmi->ref_frame)) 1354 this_mode, mbmi->ref_frame))
1351 continue; 1355 continue;
1352 1356
1353 vpx_memcpy(orig_pre, pd->pre, sizeof(orig_pre)); 1357 vpx_memcpy(orig_pre, pd->pre, sizeof(orig_pre));
1354 vpx_memcpy(bsi->rdstat[i][mode_idx].ta, t_above, 1358 vpx_memcpy(bsi->rdstat[i][mode_idx].ta, t_above,
1355 sizeof(bsi->rdstat[i][mode_idx].ta)); 1359 sizeof(bsi->rdstat[i][mode_idx].ta));
1356 vpx_memcpy(bsi->rdstat[i][mode_idx].tl, t_left, 1360 vpx_memcpy(bsi->rdstat[i][mode_idx].tl, t_left,
1357 sizeof(bsi->rdstat[i][mode_idx].tl)); 1361 sizeof(bsi->rdstat[i][mode_idx].tl));
1358 1362
1359 // motion search for newmv (single predictor case only) 1363 // motion search for newmv (single predictor case only)
(...skipping 349 matching lines...) Expand 10 before | Expand all | Expand 10 after
1709 const int64_t tx_size_diff[TX_MODES], 1713 const int64_t tx_size_diff[TX_MODES],
1710 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS], 1714 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS],
1711 int skippable) { 1715 int skippable) {
1712 MACROBLOCKD *const xd = &x->e_mbd; 1716 MACROBLOCKD *const xd = &x->e_mbd;
1713 1717
1714 // Take a snapshot of the coding context so it can be 1718 // Take a snapshot of the coding context so it can be
1715 // restored if we decide to encode this way 1719 // restored if we decide to encode this way
1716 ctx->skip = x->skip; 1720 ctx->skip = x->skip;
1717 ctx->skippable = skippable; 1721 ctx->skippable = skippable;
1718 ctx->best_mode_index = mode_index; 1722 ctx->best_mode_index = mode_index;
1719 ctx->mic = *xd->mi[0]; 1723 ctx->mic = *xd->mi[0].src_mi;
1720 ctx->single_pred_diff = (int)comp_pred_diff[SINGLE_REFERENCE]; 1724 ctx->single_pred_diff = (int)comp_pred_diff[SINGLE_REFERENCE];
1721 ctx->comp_pred_diff = (int)comp_pred_diff[COMPOUND_REFERENCE]; 1725 ctx->comp_pred_diff = (int)comp_pred_diff[COMPOUND_REFERENCE];
1722 ctx->hybrid_pred_diff = (int)comp_pred_diff[REFERENCE_MODE_SELECT]; 1726 ctx->hybrid_pred_diff = (int)comp_pred_diff[REFERENCE_MODE_SELECT];
1723 1727
1724 vpx_memcpy(ctx->tx_rd_diff, tx_size_diff, sizeof(ctx->tx_rd_diff)); 1728 vpx_memcpy(ctx->tx_rd_diff, tx_size_diff, sizeof(ctx->tx_rd_diff));
1725 vpx_memcpy(ctx->best_filter_diff, best_filter_diff, 1729 vpx_memcpy(ctx->best_filter_diff, best_filter_diff,
1726 sizeof(*best_filter_diff) * SWITCHABLE_FILTER_CONTEXTS); 1730 sizeof(*best_filter_diff) * SWITCHABLE_FILTER_CONTEXTS);
1727 } 1731 }
1728 1732
1729 static void setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x, 1733 static void setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
1730 const TileInfo *const tile, 1734 const TileInfo *const tile,
1731 MV_REFERENCE_FRAME ref_frame, 1735 MV_REFERENCE_FRAME ref_frame,
1732 BLOCK_SIZE block_size, 1736 BLOCK_SIZE block_size,
1733 int mi_row, int mi_col, 1737 int mi_row, int mi_col,
1734 int_mv frame_nearest_mv[MAX_REF_FRAMES], 1738 int_mv frame_nearest_mv[MAX_REF_FRAMES],
1735 int_mv frame_near_mv[MAX_REF_FRAMES], 1739 int_mv frame_near_mv[MAX_REF_FRAMES],
1736 struct buf_2d yv12_mb[4][MAX_MB_PLANE]) { 1740 struct buf_2d yv12_mb[4][MAX_MB_PLANE]) {
1737 const VP9_COMMON *cm = &cpi->common; 1741 const VP9_COMMON *cm = &cpi->common;
1738 const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame); 1742 const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
1739 MACROBLOCKD *const xd = &x->e_mbd; 1743 MACROBLOCKD *const xd = &x->e_mbd;
1740 MODE_INFO *const mi = xd->mi[0]; 1744 MODE_INFO *const mi = xd->mi[0].src_mi;
1741 int_mv *const candidates = mi->mbmi.ref_mvs[ref_frame]; 1745 int_mv *const candidates = mi->mbmi.ref_mvs[ref_frame];
1742 const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf; 1746 const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
1743 1747
1744 // TODO(jkoleszar): Is the UV buffer ever used here? If so, need to make this 1748 // TODO(jkoleszar): Is the UV buffer ever used here? If so, need to make this
1745 // use the UV scaling factors. 1749 // use the UV scaling factors.
1746 vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf); 1750 vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf);
1747 1751
1748 // Gets an initial list of candidate vectors from neighbours and orders them 1752 // Gets an initial list of candidate vectors from neighbours and orders them
1749 vp9_find_mv_refs(cm, xd, tile, mi, ref_frame, candidates, mi_row, mi_col); 1753 vp9_find_mv_refs(cm, xd, tile, mi, ref_frame, candidates, mi_row, mi_col);
1750 1754
1751 // Candidate refinement carried out at encoder and decoder 1755 // Candidate refinement carried out at encoder and decoder
1752 vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates, 1756 vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates,
1753 &frame_nearest_mv[ref_frame], 1757 &frame_nearest_mv[ref_frame],
1754 &frame_near_mv[ref_frame]); 1758 &frame_near_mv[ref_frame]);
1755 1759
1756 // Further refinement that is encode side only to test the top few candidates 1760 // Further refinement that is encode side only to test the top few candidates
1757 // in full and choose the best as the centre point for subsequent searches. 1761 // in full and choose the best as the centre point for subsequent searches.
1758 // The current implementation doesn't support scaling. 1762 // The current implementation doesn't support scaling.
1759 if (!vp9_is_scaled(sf) && block_size >= BLOCK_8X8) 1763 if (!vp9_is_scaled(sf) && block_size >= BLOCK_8X8)
1760 vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride, 1764 vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride,
1761 ref_frame, block_size); 1765 ref_frame, block_size);
1762 } 1766 }
1763 1767
1764 static void single_motion_search(VP9_COMP *cpi, MACROBLOCK *x, 1768 static void single_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
1765 BLOCK_SIZE bsize, 1769 BLOCK_SIZE bsize,
1766 int mi_row, int mi_col, 1770 int mi_row, int mi_col,
1767 int_mv *tmp_mv, int *rate_mv) { 1771 int_mv *tmp_mv, int *rate_mv) {
1768 MACROBLOCKD *xd = &x->e_mbd; 1772 MACROBLOCKD *xd = &x->e_mbd;
1769 const VP9_COMMON *cm = &cpi->common; 1773 const VP9_COMMON *cm = &cpi->common;
1770 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 1774 MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
1771 struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}}; 1775 struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}};
1772 int bestsme = INT_MAX; 1776 int bestsme = INT_MAX;
1773 int step_param; 1777 int step_param;
1774 int sadpb = x->sadperbit16; 1778 int sadpb = x->sadperbit16;
1775 MV mvp_full; 1779 MV mvp_full;
1776 int ref = mbmi->ref_frame[0]; 1780 int ref = mbmi->ref_frame[0];
1777 MV ref_mv = mbmi->ref_mvs[ref][0].as_mv; 1781 MV ref_mv = mbmi->ref_mvs[ref][0].as_mv;
1778 1782
1779 int tmp_col_min = x->mv_col_min; 1783 int tmp_col_min = x->mv_col_min;
1780 int tmp_col_max = x->mv_col_max; 1784 int tmp_col_max = x->mv_col_max;
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after
1887 1891
1888 static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x, 1892 static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
1889 BLOCK_SIZE bsize, 1893 BLOCK_SIZE bsize,
1890 int_mv *frame_mv, 1894 int_mv *frame_mv,
1891 int mi_row, int mi_col, 1895 int mi_row, int mi_col,
1892 int_mv single_newmv[MAX_REF_FRAMES], 1896 int_mv single_newmv[MAX_REF_FRAMES],
1893 int *rate_mv) { 1897 int *rate_mv) {
1894 const int pw = 4 * num_4x4_blocks_wide_lookup[bsize]; 1898 const int pw = 4 * num_4x4_blocks_wide_lookup[bsize];
1895 const int ph = 4 * num_4x4_blocks_high_lookup[bsize]; 1899 const int ph = 4 * num_4x4_blocks_high_lookup[bsize];
1896 MACROBLOCKD *xd = &x->e_mbd; 1900 MACROBLOCKD *xd = &x->e_mbd;
1897 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 1901 MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
1898 const int refs[2] = { mbmi->ref_frame[0], 1902 const int refs[2] = { mbmi->ref_frame[0],
1899 mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1] }; 1903 mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1] };
1900 int_mv ref_mv[2]; 1904 int_mv ref_mv[2];
1901 int ite, ref; 1905 int ite, ref;
1902 // Prediction buffer from second frame. 1906 // Prediction buffer from second frame.
1903 uint8_t *second_pred = vpx_memalign(16, pw * ph * sizeof(uint8_t)); 1907 uint8_t *second_pred = vpx_memalign(16, pw * ph * sizeof(uint8_t));
1904 const InterpKernel *kernel = vp9_get_interp_kernel(mbmi->interp_filter); 1908 const InterpKernel *kernel = vp9_get_interp_kernel(mbmi->interp_filter);
1905 1909
1906 // Do joint motion search in compound mode to get more accurate mv. 1910 // Do joint motion search in compound mode to get more accurate mv.
1907 struct buf_2d backup_yv12[2][MAX_MB_PLANE]; 1911 struct buf_2d backup_yv12[2][MAX_MB_PLANE];
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after
2129 int_mv (*mode_mv)[MAX_REF_FRAMES], 2133 int_mv (*mode_mv)[MAX_REF_FRAMES],
2130 int mi_row, int mi_col, 2134 int mi_row, int mi_col,
2131 int_mv single_newmv[MAX_REF_FRAMES], 2135 int_mv single_newmv[MAX_REF_FRAMES],
2132 INTERP_FILTER (*single_filter)[MAX_REF_FRAMES], 2136 INTERP_FILTER (*single_filter)[MAX_REF_FRAMES],
2133 int (*single_skippable)[MAX_REF_FRAMES], 2137 int (*single_skippable)[MAX_REF_FRAMES],
2134 int64_t *psse, 2138 int64_t *psse,
2135 const int64_t ref_best_rd) { 2139 const int64_t ref_best_rd) {
2136 VP9_COMMON *cm = &cpi->common; 2140 VP9_COMMON *cm = &cpi->common;
2137 RD_OPT *rd_opt = &cpi->rd; 2141 RD_OPT *rd_opt = &cpi->rd;
2138 MACROBLOCKD *xd = &x->e_mbd; 2142 MACROBLOCKD *xd = &x->e_mbd;
2139 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 2143 MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
2140 const int is_comp_pred = has_second_ref(mbmi); 2144 const int is_comp_pred = has_second_ref(mbmi);
2141 const int this_mode = mbmi->mode; 2145 const int this_mode = mbmi->mode;
2142 int_mv *frame_mv = mode_mv[this_mode]; 2146 int_mv *frame_mv = mode_mv[this_mode];
2143 int i; 2147 int i;
2144 int refs[2] = { mbmi->ref_frame[0], 2148 int refs[2] = { mbmi->ref_frame[0],
2145 (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) }; 2149 (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) };
2146 int_mv cur_mv[2]; 2150 int_mv cur_mv[2];
2147 int64_t this_rd = 0; 2151 int64_t this_rd = 0;
2148 DECLARE_ALIGNED_ARRAY(16, uint8_t, tmp_buf, MAX_MB_PLANE * 64 * 64); 2152 DECLARE_ALIGNED_ARRAY(16, uint8_t, tmp_buf, MAX_MB_PLANE * 64 * 64);
2149 int pred_exists = 0; 2153 int pred_exists = 0;
2150 int intpel_mv; 2154 int intpel_mv;
2151 int64_t rd, tmp_rd, best_rd = INT64_MAX; 2155 int64_t rd, tmp_rd, best_rd = INT64_MAX;
2152 int best_needs_copy = 0; 2156 int best_needs_copy = 0;
2153 uint8_t *orig_dst[MAX_MB_PLANE]; 2157 uint8_t *orig_dst[MAX_MB_PLANE];
2154 int orig_dst_stride[MAX_MB_PLANE]; 2158 int orig_dst_stride[MAX_MB_PLANE];
2155 int rs = 0; 2159 int rs = 0;
2156 INTERP_FILTER best_filter = SWITCHABLE; 2160 INTERP_FILTER best_filter = SWITCHABLE;
2157 uint8_t skip_txfm[MAX_MB_PLANE << 2] = {0}; 2161 uint8_t skip_txfm[MAX_MB_PLANE << 2] = {0};
2158 int64_t bsse[MAX_MB_PLANE << 2] = {0}; 2162 int64_t bsse[MAX_MB_PLANE << 2] = {0};
2159 2163
2160 int bsl = mi_width_log2_lookup[bsize]; 2164 int bsl = mi_width_log2_lookup[bsize];
2161 int pred_filter_search = cpi->sf.cb_pred_filter_search ? 2165 int pred_filter_search = cpi->sf.cb_pred_filter_search ?
2162 (((mi_row + mi_col) >> bsl) + 2166 (((mi_row + mi_col) >> bsl) +
2163 get_chessboard_index(cm->current_video_frame)) & 0x1 : 0; 2167 get_chessboard_index(cm->current_video_frame)) & 0x1 : 0;
2164 2168
2165 if (pred_filter_search) { 2169 if (pred_filter_search) {
2166 INTERP_FILTER af = SWITCHABLE, lf = SWITCHABLE; 2170 INTERP_FILTER af = SWITCHABLE, lf = SWITCHABLE;
2167 if (xd->up_available) 2171 if (xd->up_available)
2168 af = xd->mi[-xd->mi_stride]->mbmi.interp_filter; 2172 af = xd->mi[-xd->mi_stride].src_mi->mbmi.interp_filter;
2169 if (xd->left_available) 2173 if (xd->left_available)
2170 lf = xd->mi[-1]->mbmi.interp_filter; 2174 lf = xd->mi[-1].src_mi->mbmi.interp_filter;
2171 2175
2172 if ((this_mode != NEWMV) || (af == lf)) 2176 if ((this_mode != NEWMV) || (af == lf))
2173 best_filter = af; 2177 best_filter = af;
2174 } 2178 }
2175 2179
2176 if (is_comp_pred) { 2180 if (is_comp_pred) {
2177 if (frame_mv[refs[0]].as_int == INVALID_MV || 2181 if (frame_mv[refs[0]].as_int == INVALID_MV ||
2178 frame_mv[refs[1]].as_int == INVALID_MV) 2182 frame_mv[refs[1]].as_int == INVALID_MV)
2179 return INT64_MAX; 2183 return INT64_MAX;
2180 2184
(...skipping 24 matching lines...) Expand all
2205 } 2209 }
2206 *rate2 += rate_mv; 2210 *rate2 += rate_mv;
2207 } else { 2211 } else {
2208 int_mv tmp_mv; 2212 int_mv tmp_mv;
2209 single_motion_search(cpi, x, bsize, mi_row, mi_col, 2213 single_motion_search(cpi, x, bsize, mi_row, mi_col,
2210 &tmp_mv, &rate_mv); 2214 &tmp_mv, &rate_mv);
2211 if (tmp_mv.as_int == INVALID_MV) 2215 if (tmp_mv.as_int == INVALID_MV)
2212 return INT64_MAX; 2216 return INT64_MAX;
2213 *rate2 += rate_mv; 2217 *rate2 += rate_mv;
2214 frame_mv[refs[0]].as_int = 2218 frame_mv[refs[0]].as_int =
2215 xd->mi[0]->bmi[0].as_mv[0].as_int = tmp_mv.as_int; 2219 xd->mi[0].src_mi->bmi[0].as_mv[0].as_int = tmp_mv.as_int;
2216 single_newmv[refs[0]].as_int = tmp_mv.as_int; 2220 single_newmv[refs[0]].as_int = tmp_mv.as_int;
2217 } 2221 }
2218 } 2222 }
2219 2223
2220 for (i = 0; i < is_comp_pred + 1; ++i) { 2224 for (i = 0; i < is_comp_pred + 1; ++i) {
2221 cur_mv[i] = frame_mv[refs[i]]; 2225 cur_mv[i] = frame_mv[refs[i]];
2222 // Clip "next_nearest" so that it does not extend to far out of image 2226 // Clip "next_nearest" so that it does not extend to far out of image
2223 if (this_mode != NEWMV) 2227 if (this_mode != NEWMV)
2224 clamp_mv2(&cur_mv[i].as_mv, xd); 2228 clamp_mv2(&cur_mv[i].as_mv, xd);
2225 2229
(...skipping 231 matching lines...) Expand 10 before | Expand all | Expand 10 after
2457 PICK_MODE_CONTEXT *ctx, int64_t best_rd) { 2461 PICK_MODE_CONTEXT *ctx, int64_t best_rd) {
2458 VP9_COMMON *const cm = &cpi->common; 2462 VP9_COMMON *const cm = &cpi->common;
2459 MACROBLOCKD *const xd = &x->e_mbd; 2463 MACROBLOCKD *const xd = &x->e_mbd;
2460 struct macroblockd_plane *const pd = xd->plane; 2464 struct macroblockd_plane *const pd = xd->plane;
2461 int rate_y = 0, rate_uv = 0, rate_y_tokenonly = 0, rate_uv_tokenonly = 0; 2465 int rate_y = 0, rate_uv = 0, rate_y_tokenonly = 0, rate_uv_tokenonly = 0;
2462 int y_skip = 0, uv_skip = 0; 2466 int y_skip = 0, uv_skip = 0;
2463 int64_t dist_y = 0, dist_uv = 0, tx_cache[TX_MODES] = { 0 }; 2467 int64_t dist_y = 0, dist_uv = 0, tx_cache[TX_MODES] = { 0 };
2464 TX_SIZE max_uv_tx_size; 2468 TX_SIZE max_uv_tx_size;
2465 x->skip_encode = 0; 2469 x->skip_encode = 0;
2466 ctx->skip = 0; 2470 ctx->skip = 0;
2467 xd->mi[0]->mbmi.ref_frame[0] = INTRA_FRAME; 2471 xd->mi[0].src_mi->mbmi.ref_frame[0] = INTRA_FRAME;
2468 2472
2469 if (bsize >= BLOCK_8X8) { 2473 if (bsize >= BLOCK_8X8) {
2470 if (rd_pick_intra_sby_mode(cpi, x, &rate_y, &rate_y_tokenonly, 2474 if (rd_pick_intra_sby_mode(cpi, x, &rate_y, &rate_y_tokenonly,
2471 &dist_y, &y_skip, bsize, tx_cache, 2475 &dist_y, &y_skip, bsize, tx_cache,
2472 best_rd) >= best_rd) { 2476 best_rd) >= best_rd) {
2473 *returnrate = INT_MAX; 2477 *returnrate = INT_MAX;
2474 return; 2478 return;
2475 } 2479 }
2476 max_uv_tx_size = get_uv_tx_size_impl(xd->mi[0]->mbmi.tx_size, bsize, 2480 max_uv_tx_size = get_uv_tx_size_impl(xd->mi[0].src_mi->mbmi.tx_size, bsize,
2477 pd[1].subsampling_x, 2481 pd[1].subsampling_x,
2478 pd[1].subsampling_y); 2482 pd[1].subsampling_y);
2479 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv, &rate_uv_tokenonly, 2483 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv, &rate_uv_tokenonly,
2480 &dist_uv, &uv_skip, bsize, max_uv_tx_size); 2484 &dist_uv, &uv_skip, bsize, max_uv_tx_size);
2481 } else { 2485 } else {
2482 y_skip = 0; 2486 y_skip = 0;
2483 if (rd_pick_intra_sub_8x8_y_mode(cpi, x, &rate_y, &rate_y_tokenonly, 2487 if (rd_pick_intra_sub_8x8_y_mode(cpi, x, &rate_y, &rate_y_tokenonly,
2484 &dist_y, best_rd) >= best_rd) { 2488 &dist_y, best_rd) >= best_rd) {
2485 *returnrate = INT_MAX; 2489 *returnrate = INT_MAX;
2486 return; 2490 return;
2487 } 2491 }
2488 max_uv_tx_size = get_uv_tx_size_impl(xd->mi[0]->mbmi.tx_size, bsize, 2492 max_uv_tx_size = get_uv_tx_size_impl(xd->mi[0].src_mi->mbmi.tx_size, bsize,
2489 pd[1].subsampling_x, 2493 pd[1].subsampling_x,
2490 pd[1].subsampling_y); 2494 pd[1].subsampling_y);
2491 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv, &rate_uv_tokenonly, 2495 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv, &rate_uv_tokenonly,
2492 &dist_uv, &uv_skip, BLOCK_8X8, max_uv_tx_size); 2496 &dist_uv, &uv_skip, BLOCK_8X8, max_uv_tx_size);
2493 } 2497 }
2494 2498
2495 if (y_skip && uv_skip) { 2499 if (y_skip && uv_skip) {
2496 *returnrate = rate_y + rate_uv - rate_y_tokenonly - rate_uv_tokenonly + 2500 *returnrate = rate_y + rate_uv - rate_y_tokenonly - rate_uv_tokenonly +
2497 vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); 2501 vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
2498 *returndist = dist_y + dist_uv; 2502 *returndist = dist_y + dist_uv;
2499 vp9_zero(ctx->tx_rd_diff); 2503 vp9_zero(ctx->tx_rd_diff);
2500 } else { 2504 } else {
2501 int i; 2505 int i;
2502 *returnrate = rate_y + rate_uv + vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0); 2506 *returnrate = rate_y + rate_uv + vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
2503 *returndist = dist_y + dist_uv; 2507 *returndist = dist_y + dist_uv;
2504 if (cpi->sf.tx_size_search_method == USE_FULL_RD) 2508 if (cpi->sf.tx_size_search_method == USE_FULL_RD)
2505 for (i = 0; i < TX_MODES; i++) { 2509 for (i = 0; i < TX_MODES; i++) {
2506 if (tx_cache[i] < INT64_MAX && tx_cache[cm->tx_mode] < INT64_MAX) 2510 if (tx_cache[i] < INT64_MAX && tx_cache[cm->tx_mode] < INT64_MAX)
2507 ctx->tx_rd_diff[i] = tx_cache[i] - tx_cache[cm->tx_mode]; 2511 ctx->tx_rd_diff[i] = tx_cache[i] - tx_cache[cm->tx_mode];
2508 else 2512 else
2509 ctx->tx_rd_diff[i] = 0; 2513 ctx->tx_rd_diff[i] = 0;
2510 } 2514 }
2511 } 2515 }
2512 2516
2513 ctx->mic = *xd->mi[0]; 2517 ctx->mic = *xd->mi[0].src_mi;
2514 } 2518 }
2515 2519
2516 // Updating rd_thresh_freq_fact[] here means that the different 2520 // Updating rd_thresh_freq_fact[] here means that the different
2517 // partition/block sizes are handled independently based on the best 2521 // partition/block sizes are handled independently based on the best
2518 // choice for the current partition. It may well be better to keep a scaled 2522 // choice for the current partition. It may well be better to keep a scaled
2519 // best rd so far value and update rd_thresh_freq_fact based on the mode/size 2523 // best rd so far value and update rd_thresh_freq_fact based on the mode/size
2520 // combination that wins out. 2524 // combination that wins out.
2521 static void update_rd_thresh_fact(VP9_COMP *cpi, int bsize, 2525 static void update_rd_thresh_fact(VP9_COMP *cpi, int bsize,
2522 int best_mode_index) { 2526 int best_mode_index) {
2523 if (cpi->sf.adaptive_rd_thresh > 0) { 2527 if (cpi->sf.adaptive_rd_thresh > 0) {
(...skipping 16 matching lines...) Expand all
2540 const TileInfo *const tile, 2544 const TileInfo *const tile,
2541 int mi_row, int mi_col, 2545 int mi_row, int mi_col,
2542 int *returnrate, 2546 int *returnrate,
2543 int64_t *returndistortion, 2547 int64_t *returndistortion,
2544 BLOCK_SIZE bsize, 2548 BLOCK_SIZE bsize,
2545 PICK_MODE_CONTEXT *ctx, 2549 PICK_MODE_CONTEXT *ctx,
2546 int64_t best_rd_so_far) { 2550 int64_t best_rd_so_far) {
2547 VP9_COMMON *const cm = &cpi->common; 2551 VP9_COMMON *const cm = &cpi->common;
2548 RD_OPT *const rd_opt = &cpi->rd; 2552 RD_OPT *const rd_opt = &cpi->rd;
2549 MACROBLOCKD *const xd = &x->e_mbd; 2553 MACROBLOCKD *const xd = &x->e_mbd;
2550 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 2554 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
2551 const struct segmentation *const seg = &cm->seg; 2555 const struct segmentation *const seg = &cm->seg;
2552 struct macroblockd_plane *const pd = xd->plane; 2556 struct macroblockd_plane *const pd = xd->plane;
2553 PREDICTION_MODE this_mode; 2557 PREDICTION_MODE this_mode;
2554 MV_REFERENCE_FRAME ref_frame, second_ref_frame; 2558 MV_REFERENCE_FRAME ref_frame, second_ref_frame;
2555 unsigned char segment_id = mbmi->segment_id; 2559 unsigned char segment_id = mbmi->segment_id;
2556 int comp_pred, i, k; 2560 int comp_pred, i, k;
2557 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; 2561 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
2558 struct buf_2d yv12_mb[4][MAX_MB_PLANE]; 2562 struct buf_2d yv12_mb[4][MAX_MB_PLANE];
2559 int_mv single_newmv[MAX_REF_FRAMES] = { { 0 } }; 2563 int_mv single_newmv[MAX_REF_FRAMES] = { { 0 } };
2560 INTERP_FILTER single_inter_filter[MB_MODE_COUNT][MAX_REF_FRAMES]; 2564 INTERP_FILTER single_inter_filter[MB_MODE_COUNT][MAX_REF_FRAMES];
2561 int single_skippable[MB_MODE_COUNT][MAX_REF_FRAMES]; 2565 int single_skippable[MB_MODE_COUNT][MAX_REF_FRAMES];
2562 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, 2566 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
2563 VP9_ALT_FLAG }; 2567 VP9_ALT_FLAG };
2564 int64_t best_rd = best_rd_so_far; 2568 int64_t best_rd = best_rd_so_far;
2565 int64_t best_tx_rd[TX_MODES]; 2569 int64_t best_tx_rd[TX_MODES];
2566 int64_t best_tx_diff[TX_MODES]; 2570 int64_t best_tx_diff[TX_MODES];
2567 int64_t best_pred_diff[REFERENCE_MODES]; 2571 int64_t best_pred_diff[REFERENCE_MODES];
2568 int64_t best_pred_rd[REFERENCE_MODES]; 2572 int64_t best_pred_rd[REFERENCE_MODES];
2569 int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS]; 2573 int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
2570 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS]; 2574 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
2571 MB_MODE_INFO best_mbmode; 2575 MB_MODE_INFO best_mbmode;
2572 int best_mode_skippable = 0; 2576 int best_mode_skippable = 0;
2573 int mode_index, best_mode_index = -1; 2577 int midx, best_mode_index = -1;
2574 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES]; 2578 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
2575 vp9_prob comp_mode_p; 2579 vp9_prob comp_mode_p;
2576 int64_t best_intra_rd = INT64_MAX; 2580 int64_t best_intra_rd = INT64_MAX;
2577 int64_t best_inter_rd = INT64_MAX; 2581 unsigned int best_pred_sse = UINT_MAX;
2578 PREDICTION_MODE best_intra_mode = DC_PRED; 2582 PREDICTION_MODE best_intra_mode = DC_PRED;
2579 MV_REFERENCE_FRAME best_inter_ref_frame = LAST_FRAME;
2580 int rate_uv_intra[TX_SIZES], rate_uv_tokenonly[TX_SIZES]; 2583 int rate_uv_intra[TX_SIZES], rate_uv_tokenonly[TX_SIZES];
2581 int64_t dist_uv[TX_SIZES]; 2584 int64_t dist_uv[TX_SIZES];
2582 int skip_uv[TX_SIZES]; 2585 int skip_uv[TX_SIZES];
2583 PREDICTION_MODE mode_uv[TX_SIZES]; 2586 PREDICTION_MODE mode_uv[TX_SIZES];
2584 int intra_cost_penalty = 20 * vp9_dc_quant(cm->base_qindex, cm->y_dc_delta_q); 2587 const int intra_cost_penalty =
2588 20 * vp9_dc_quant(cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth);
2585 int best_skip2 = 0; 2589 int best_skip2 = 0;
2586 int mode_skip_mask = 0; 2590 uint8_t ref_frame_skip_mask[2] = { 0 };
2591 uint16_t mode_skip_mask[MAX_REF_FRAMES] = { 0 };
2587 int mode_skip_start = cpi->sf.mode_skip_start + 1; 2592 int mode_skip_start = cpi->sf.mode_skip_start + 1;
2588 const int *const rd_threshes = rd_opt->threshes[segment_id][bsize]; 2593 const int *const rd_threshes = rd_opt->threshes[segment_id][bsize];
2589 const int *const rd_thresh_freq_fact = rd_opt->thresh_freq_fact[bsize]; 2594 const int *const rd_thresh_freq_fact = rd_opt->thresh_freq_fact[bsize];
2595 int mode_threshold[MAX_MODES];
2596 int *mode_map = rd_opt->mode_map[bsize];
2590 const int mode_search_skip_flags = cpi->sf.mode_search_skip_flags; 2597 const int mode_search_skip_flags = cpi->sf.mode_search_skip_flags;
2591 const int intra_y_mode_mask =
2592 cpi->sf.intra_y_mode_mask[max_txsize_lookup[bsize]];
2593 int inter_mode_mask = cpi->sf.inter_mode_mask[bsize];
2594 vp9_zero(best_mbmode); 2598 vp9_zero(best_mbmode);
2599
2595 x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; 2600 x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
2596 2601
2597 estimate_ref_frame_costs(cm, xd, segment_id, ref_costs_single, ref_costs_comp, 2602 estimate_ref_frame_costs(cm, xd, segment_id, ref_costs_single, ref_costs_comp,
2598 &comp_mode_p); 2603 &comp_mode_p);
2599 2604
2600 for (i = 0; i < REFERENCE_MODES; ++i) 2605 for (i = 0; i < REFERENCE_MODES; ++i)
2601 best_pred_rd[i] = INT64_MAX; 2606 best_pred_rd[i] = INT64_MAX;
2602 for (i = 0; i < TX_MODES; i++) 2607 for (i = 0; i < TX_MODES; i++)
2603 best_tx_rd[i] = INT64_MAX; 2608 best_tx_rd[i] = INT64_MAX;
2604 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) 2609 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
(...skipping 15 matching lines...) Expand all
2620 x->pred_mv_sad[ref_frame] = INT_MAX; 2625 x->pred_mv_sad[ref_frame] = INT_MAX;
2621 if (cpi->ref_frame_flags & flag_list[ref_frame]) { 2626 if (cpi->ref_frame_flags & flag_list[ref_frame]) {
2622 setup_buffer_inter(cpi, x, tile, ref_frame, bsize, mi_row, mi_col, 2627 setup_buffer_inter(cpi, x, tile, ref_frame, bsize, mi_row, mi_col,
2623 frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb); 2628 frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
2624 } 2629 }
2625 frame_mv[NEWMV][ref_frame].as_int = INVALID_MV; 2630 frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
2626 frame_mv[ZEROMV][ref_frame].as_int = 0; 2631 frame_mv[ZEROMV][ref_frame].as_int = 0;
2627 } 2632 }
2628 2633
2629 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { 2634 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
2630 // All modes from vp9_mode_order that use this frame as any ref
2631 static const int ref_frame_mask_all[] = {
2632 0x0, 0x123291, 0x25c444, 0x39b722
2633 };
2634 // Fixed mv modes (NEARESTMV, NEARMV, ZEROMV) from vp9_mode_order that use
2635 // this frame as their primary ref
2636 static const int ref_frame_mask_fixedmv[] = {
2637 0x0, 0x121281, 0x24c404, 0x080102
2638 };
2639 if (!(cpi->ref_frame_flags & flag_list[ref_frame])) { 2635 if (!(cpi->ref_frame_flags & flag_list[ref_frame])) {
2640 // Skip modes for missing references 2636 // Skip checking missing references in both single and compound reference
2641 mode_skip_mask |= ref_frame_mask_all[ref_frame]; 2637 // modes. Note that a mode will be skipped iff both reference frames
2638 // are masked out.
2639 ref_frame_skip_mask[0] |= (1 << ref_frame);
2640 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
2642 } else if (cpi->sf.reference_masking) { 2641 } else if (cpi->sf.reference_masking) {
2643 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { 2642 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
2644 // Skip fixed mv modes for poor references 2643 // Skip fixed mv modes for poor references
2645 if ((x->pred_mv_sad[ref_frame] >> 2) > x->pred_mv_sad[i]) { 2644 if ((x->pred_mv_sad[ref_frame] >> 2) > x->pred_mv_sad[i]) {
2646 mode_skip_mask |= ref_frame_mask_fixedmv[ref_frame]; 2645 mode_skip_mask[ref_frame] |= INTER_NEAREST_NEAR_ZERO;
2647 break; 2646 break;
2648 } 2647 }
2649 } 2648 }
2650 } 2649 }
2651 // If the segment reference frame feature is enabled.... 2650 // If the segment reference frame feature is enabled....
2652 // then do nothing if the current ref frame is not allowed.. 2651 // then do nothing if the current ref frame is not allowed..
2653 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) && 2652 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
2654 vp9_get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) { 2653 vp9_get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) {
2655 mode_skip_mask |= ref_frame_mask_all[ref_frame]; 2654 ref_frame_skip_mask[0] |= (1 << ref_frame);
2655 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
2656 } 2656 }
2657 } 2657 }
2658 2658
2659 // Disable this drop out case if the ref frame 2659 // Disable this drop out case if the ref frame
2660 // segment level feature is enabled for this segment. This is to 2660 // segment level feature is enabled for this segment. This is to
2661 // prevent the possibility that we end up unable to pick any mode. 2661 // prevent the possibility that we end up unable to pick any mode.
2662 if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) { 2662 if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) {
2663 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame, 2663 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
2664 // unless ARNR filtering is enabled in which case we want 2664 // unless ARNR filtering is enabled in which case we want
2665 // an unfiltered alternative. We allow near/nearest as well 2665 // an unfiltered alternative. We allow near/nearest as well
2666 // because they may result in zero-zero MVs but be cheaper. 2666 // because they may result in zero-zero MVs but be cheaper.
2667 if (cpi->rc.is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) { 2667 if (cpi->rc.is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {
2668 mode_skip_mask = 2668 ref_frame_skip_mask[0] = (1 << LAST_FRAME) | (1 << GOLDEN_FRAME);
2669 ~((1 << THR_NEARESTA) | (1 << THR_NEARA) | (1 << THR_ZEROA)); 2669 ref_frame_skip_mask[1] = SECOND_REF_FRAME_MASK;
2670 mode_skip_mask[ALTREF_FRAME] = ~INTER_NEAREST_NEAR_ZERO;
2670 if (frame_mv[NEARMV][ALTREF_FRAME].as_int != 0) 2671 if (frame_mv[NEARMV][ALTREF_FRAME].as_int != 0)
2671 mode_skip_mask |= (1 << THR_NEARA); 2672 mode_skip_mask[ALTREF_FRAME] |= (1 << NEARMV);
2672 if (frame_mv[NEARESTMV][ALTREF_FRAME].as_int != 0) 2673 if (frame_mv[NEARESTMV][ALTREF_FRAME].as_int != 0)
2673 mode_skip_mask |= (1 << THR_NEARESTA); 2674 mode_skip_mask[ALTREF_FRAME] |= (1 << NEARESTMV);
2675 }
2676 }
2677
2678 if (cpi->rc.is_src_frame_alt_ref) {
2679 if (cpi->sf.alt_ref_search_fp) {
2680 mode_skip_mask[ALTREF_FRAME] = 0;
2681 ref_frame_skip_mask[0] = ~(1 << ALTREF_FRAME);
2682 ref_frame_skip_mask[1] = SECOND_REF_FRAME_MASK;
2674 } 2683 }
2675 } 2684 }
2676 2685
2677 if (bsize > cpi->sf.max_intra_bsize) { 2686 if (bsize > cpi->sf.max_intra_bsize) {
2678 const int all_intra_modes = (1 << THR_DC) | (1 << THR_TM) | 2687 ref_frame_skip_mask[0] |= (1 << INTRA_FRAME);
2679 (1 << THR_H_PRED) | (1 << THR_V_PRED) | (1 << THR_D135_PRED) | 2688 ref_frame_skip_mask[1] |= (1 << INTRA_FRAME);
2680 (1 << THR_D207_PRED) | (1 << THR_D153_PRED) | (1 << THR_D63_PRED) |
2681 (1 << THR_D117_PRED) | (1 << THR_D45_PRED);
2682 mode_skip_mask |= all_intra_modes;
2683 } 2689 }
2684 2690
2685 for (mode_index = 0; mode_index < MAX_MODES; ++mode_index) { 2691 mode_skip_mask[INTRA_FRAME] |=
2692 ~(cpi->sf.intra_y_mode_mask[max_txsize_lookup[bsize]]);
2693
2694 for (i = 0; i < MAX_MODES; ++i)
2695 mode_threshold[i] = ((int64_t)rd_threshes[i] * rd_thresh_freq_fact[i]) >> 5;
2696
2697 midx = cpi->sf.schedule_mode_search ? mode_skip_start : 0;
2698 while (midx > 4) {
2699 uint8_t end_pos = 0;
2700 for (i = 5; i < midx; ++i) {
2701 if (mode_threshold[mode_map[i - 1]] > mode_threshold[mode_map[i]]) {
2702 uint8_t tmp = mode_map[i];
2703 mode_map[i] = mode_map[i - 1];
2704 mode_map[i - 1] = tmp;
2705 end_pos = i;
2706 }
2707 }
2708 midx = end_pos;
2709 }
2710
2711 for (midx = 0; midx < MAX_MODES; ++midx) {
2712 int mode_index = mode_map[midx];
2686 int mode_excluded = 0; 2713 int mode_excluded = 0;
2687 int64_t this_rd = INT64_MAX; 2714 int64_t this_rd = INT64_MAX;
2688 int disable_skip = 0; 2715 int disable_skip = 0;
2689 int compmode_cost = 0; 2716 int compmode_cost = 0;
2690 int rate2 = 0, rate_y = 0, rate_uv = 0; 2717 int rate2 = 0, rate_y = 0, rate_uv = 0;
2691 int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0; 2718 int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
2692 int skippable = 0; 2719 int skippable = 0;
2693 int64_t tx_cache[TX_MODES]; 2720 int64_t tx_cache[TX_MODES];
2694 int i;
2695 int this_skip2 = 0; 2721 int this_skip2 = 0;
2696 int64_t total_sse = INT64_MAX; 2722 int64_t total_sse = INT64_MAX;
2697 int early_term = 0; 2723 int early_term = 0;
2698 2724
2699 this_mode = vp9_mode_order[mode_index].mode; 2725 this_mode = vp9_mode_order[mode_index].mode;
2700 ref_frame = vp9_mode_order[mode_index].ref_frame[0]; 2726 ref_frame = vp9_mode_order[mode_index].ref_frame[0];
2701 if (ref_frame != INTRA_FRAME && !(inter_mode_mask & (1 << this_mode)))
2702 continue;
2703 second_ref_frame = vp9_mode_order[mode_index].ref_frame[1]; 2727 second_ref_frame = vp9_mode_order[mode_index].ref_frame[1];
2704 2728
2705 // Look at the reference frame of the best mode so far and set the 2729 // Look at the reference frame of the best mode so far and set the
2706 // skip mask to look at a subset of the remaining modes. 2730 // skip mask to look at a subset of the remaining modes.
2707 if (mode_index == mode_skip_start && best_mode_index >= 0) { 2731 if (midx == mode_skip_start && best_mode_index >= 0) {
2708 switch (vp9_mode_order[best_mode_index].ref_frame[0]) { 2732 switch (best_mbmode.ref_frame[0]) {
2709 case INTRA_FRAME: 2733 case INTRA_FRAME:
2710 break; 2734 break;
2711 case LAST_FRAME: 2735 case LAST_FRAME:
2712 mode_skip_mask |= LAST_FRAME_MODE_MASK; 2736 ref_frame_skip_mask[0] |= LAST_FRAME_MODE_MASK;
2737 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
2713 break; 2738 break;
2714 case GOLDEN_FRAME: 2739 case GOLDEN_FRAME:
2715 mode_skip_mask |= GOLDEN_FRAME_MODE_MASK; 2740 ref_frame_skip_mask[0] |= GOLDEN_FRAME_MODE_MASK;
2741 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
2716 break; 2742 break;
2717 case ALTREF_FRAME: 2743 case ALTREF_FRAME:
2718 mode_skip_mask |= ALT_REF_MODE_MASK; 2744 ref_frame_skip_mask[0] |= ALT_REF_MODE_MASK;
2719 break; 2745 break;
2720 case NONE: 2746 case NONE:
2721 case MAX_REF_FRAMES: 2747 case MAX_REF_FRAMES:
2722 assert(0 && "Invalid Reference frame"); 2748 assert(0 && "Invalid Reference frame");
2723 break; 2749 break;
2724 } 2750 }
2725 } 2751 }
2726 2752
2727 if (cpi->sf.alt_ref_search_fp && cpi->rc.is_src_frame_alt_ref) { 2753 if (ref_frame_skip_mask[0] & (1 << ref_frame) &&
2728 mode_skip_mask = 0; 2754 ref_frame_skip_mask[1] & (1 << MAX(0, second_ref_frame)))
2729 if (!(ref_frame == ALTREF_FRAME && second_ref_frame == NONE)) 2755 continue;
2730 continue;
2731 }
2732 2756
2733 if (mode_skip_mask & (1 << mode_index)) 2757 if (mode_skip_mask[ref_frame] & (1 << this_mode))
2734 continue; 2758 continue;
2735 2759
2736 // Test best rd so far against threshold for trying this mode. 2760 // Test best rd so far against threshold for trying this mode.
2737 if (rd_less_than_thresh(best_rd, rd_threshes[mode_index], 2761 if (best_mode_skippable && cpi->sf.schedule_mode_search)
2738 rd_thresh_freq_fact[mode_index])) 2762 mode_threshold[mode_index] <<= 1;
2763
2764 if (best_rd < mode_threshold[mode_index])
2739 continue; 2765 continue;
2740 2766
2741 if (cpi->sf.motion_field_mode_search) { 2767 if (cpi->sf.motion_field_mode_search) {
2742 const int mi_width = MIN(num_8x8_blocks_wide_lookup[bsize], 2768 const int mi_width = MIN(num_8x8_blocks_wide_lookup[bsize],
2743 tile->mi_col_end - mi_col); 2769 tile->mi_col_end - mi_col);
2744 const int mi_height = MIN(num_8x8_blocks_high_lookup[bsize], 2770 const int mi_height = MIN(num_8x8_blocks_high_lookup[bsize],
2745 tile->mi_row_end - mi_row); 2771 tile->mi_row_end - mi_row);
2746 const int bsl = mi_width_log2(bsize); 2772 const int bsl = mi_width_log2(bsize);
2747 int cb_partition_search_ctrl = (((mi_row + mi_col) >> bsl) 2773 int cb_partition_search_ctrl = (((mi_row + mi_col) >> bsl)
2748 + get_chessboard_index(cm->current_video_frame)) & 0x1; 2774 + get_chessboard_index(cm->current_video_frame)) & 0x1;
2749 MB_MODE_INFO *ref_mbmi; 2775 MB_MODE_INFO *ref_mbmi;
2750 int const_motion = 1; 2776 int const_motion = 1;
2751 int skip_ref_frame = !cb_partition_search_ctrl; 2777 int skip_ref_frame = !cb_partition_search_ctrl;
2752 MV_REFERENCE_FRAME rf = NONE; 2778 MV_REFERENCE_FRAME rf = NONE;
2753 int_mv ref_mv; 2779 int_mv ref_mv;
2754 ref_mv.as_int = INVALID_MV; 2780 ref_mv.as_int = INVALID_MV;
2755 2781
2756 if ((mi_row - 1) >= tile->mi_row_start) { 2782 if ((mi_row - 1) >= tile->mi_row_start) {
2757 ref_mv = xd->mi[-xd->mi_stride]->mbmi.mv[0]; 2783 ref_mv = xd->mi[-xd->mi_stride].src_mi->mbmi.mv[0];
2758 rf = xd->mi[-xd->mi_stride]->mbmi.ref_frame[0]; 2784 rf = xd->mi[-xd->mi_stride].src_mi->mbmi.ref_frame[0];
2759 for (i = 0; i < mi_width; ++i) { 2785 for (i = 0; i < mi_width; ++i) {
2760 ref_mbmi = &xd->mi[-xd->mi_stride + i]->mbmi; 2786 ref_mbmi = &xd->mi[-xd->mi_stride + i].src_mi->mbmi;
2761 const_motion &= (ref_mv.as_int == ref_mbmi->mv[0].as_int) && 2787 const_motion &= (ref_mv.as_int == ref_mbmi->mv[0].as_int) &&
2762 (ref_frame == ref_mbmi->ref_frame[0]); 2788 (ref_frame == ref_mbmi->ref_frame[0]);
2763 skip_ref_frame &= (rf == ref_mbmi->ref_frame[0]); 2789 skip_ref_frame &= (rf == ref_mbmi->ref_frame[0]);
2764 } 2790 }
2765 } 2791 }
2766 2792
2767 if ((mi_col - 1) >= tile->mi_col_start) { 2793 if ((mi_col - 1) >= tile->mi_col_start) {
2768 if (ref_mv.as_int == INVALID_MV) 2794 if (ref_mv.as_int == INVALID_MV)
2769 ref_mv = xd->mi[-1]->mbmi.mv[0]; 2795 ref_mv = xd->mi[-1].src_mi->mbmi.mv[0];
2770 if (rf == NONE) 2796 if (rf == NONE)
2771 rf = xd->mi[-1]->mbmi.ref_frame[0]; 2797 rf = xd->mi[-1].src_mi->mbmi.ref_frame[0];
2772 for (i = 0; i < mi_height; ++i) { 2798 for (i = 0; i < mi_height; ++i) {
2773 ref_mbmi = &xd->mi[i * xd->mi_stride - 1]->mbmi; 2799 ref_mbmi = &xd->mi[i * xd->mi_stride - 1].src_mi->mbmi;
2774 const_motion &= (ref_mv.as_int == ref_mbmi->mv[0].as_int) && 2800 const_motion &= (ref_mv.as_int == ref_mbmi->mv[0].as_int) &&
2775 (ref_frame == ref_mbmi->ref_frame[0]); 2801 (ref_frame == ref_mbmi->ref_frame[0]);
2776 skip_ref_frame &= (rf == ref_mbmi->ref_frame[0]); 2802 skip_ref_frame &= (rf == ref_mbmi->ref_frame[0]);
2777 } 2803 }
2778 } 2804 }
2779 2805
2780 if (skip_ref_frame && this_mode != NEARESTMV && this_mode != NEWMV) 2806 if (skip_ref_frame && this_mode != NEARESTMV && this_mode != NEWMV)
2781 if (rf > INTRA_FRAME) 2807 if (rf > INTRA_FRAME)
2782 if (ref_frame != rf) 2808 if (ref_frame != rf)
2783 continue; 2809 continue;
2784 2810
2785 if (const_motion) 2811 if (const_motion)
2786 if (this_mode == NEARMV || this_mode == ZEROMV) 2812 if (this_mode == NEARMV || this_mode == ZEROMV)
2787 continue; 2813 continue;
2788 } 2814 }
2789 2815
2790 comp_pred = second_ref_frame > INTRA_FRAME; 2816 comp_pred = second_ref_frame > INTRA_FRAME;
2791 if (comp_pred) { 2817 if (comp_pred) {
2792 if (!cm->allow_comp_inter_inter) 2818 if (!cm->allow_comp_inter_inter)
2793 continue; 2819 continue;
2794 2820
2821 // Skip compound inter modes if ARF is not available.
2822 if (!(cpi->ref_frame_flags & flag_list[second_ref_frame]))
2823 continue;
2824
2825 // Do not allow compound prediction if the segment level reference frame
2826 // feature is in use as in this case there can only be one reference.
2827 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
2828 continue;
2829
2795 if ((mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA) && 2830 if ((mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA) &&
2796 best_mode_index >=0 && 2831 best_mode_index >= 0 && best_mbmode.ref_frame[0] == INTRA_FRAME)
2797 vp9_mode_order[best_mode_index].ref_frame[0] == INTRA_FRAME)
2798 continue; 2832 continue;
2799 if ((mode_search_skip_flags & FLAG_SKIP_COMP_REFMISMATCH) && 2833
2800 ref_frame != best_inter_ref_frame &&
2801 second_ref_frame != best_inter_ref_frame)
2802 continue;
2803 mode_excluded = cm->reference_mode == SINGLE_REFERENCE; 2834 mode_excluded = cm->reference_mode == SINGLE_REFERENCE;
2804 } else { 2835 } else {
2805 if (ref_frame != INTRA_FRAME) 2836 if (ref_frame != INTRA_FRAME)
2806 mode_excluded = cm->reference_mode == COMPOUND_REFERENCE; 2837 mode_excluded = cm->reference_mode == COMPOUND_REFERENCE;
2807 } 2838 }
2808 2839
2809 if (ref_frame == INTRA_FRAME) { 2840 if (ref_frame == INTRA_FRAME) {
2810 if (cpi->sf.adaptive_mode_search) 2841 if (cpi->sf.adaptive_mode_search)
2811 if ((x->source_variance << num_pels_log2_lookup[bsize]) > best_intra_rd) 2842 if ((x->source_variance << num_pels_log2_lookup[bsize]) > best_pred_sse)
2812 continue; 2843 continue;
2813 2844
2814 if (!(intra_y_mode_mask & (1 << this_mode)))
2815 continue;
2816 if (this_mode != DC_PRED) { 2845 if (this_mode != DC_PRED) {
2817 // Disable intra modes other than DC_PRED for blocks with low variance 2846 // Disable intra modes other than DC_PRED for blocks with low variance
2818 // Threshold for intra skipping based on source variance 2847 // Threshold for intra skipping based on source variance
2819 // TODO(debargha): Specialize the threshold for super block sizes 2848 // TODO(debargha): Specialize the threshold for super block sizes
2820 const unsigned int skip_intra_var_thresh = 64; 2849 const unsigned int skip_intra_var_thresh = 64;
2821 if ((mode_search_skip_flags & FLAG_SKIP_INTRA_LOWVAR) && 2850 if ((mode_search_skip_flags & FLAG_SKIP_INTRA_LOWVAR) &&
2822 x->source_variance < skip_intra_var_thresh) 2851 x->source_variance < skip_intra_var_thresh)
2823 continue; 2852 continue;
2824 // Only search the oblique modes if the best so far is 2853 // Only search the oblique modes if the best so far is
2825 // one of the neighboring directional modes 2854 // one of the neighboring directional modes
2826 if ((mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER) && 2855 if ((mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER) &&
2827 (this_mode >= D45_PRED && this_mode <= TM_PRED)) { 2856 (this_mode >= D45_PRED && this_mode <= TM_PRED)) {
2828 if (best_mode_index >= 0 && 2857 if (best_mode_index >= 0 &&
2829 vp9_mode_order[best_mode_index].ref_frame[0] > INTRA_FRAME) 2858 best_mbmode.ref_frame[0] > INTRA_FRAME)
2830 continue; 2859 continue;
2831 } 2860 }
2832 if (mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH) { 2861 if (mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH) {
2833 if (conditional_skipintra(this_mode, best_intra_mode)) 2862 if (conditional_skipintra(this_mode, best_intra_mode))
2834 continue; 2863 continue;
2835 } 2864 }
2836 } 2865 }
2837 } else { 2866 } else {
2838 const MV_REFERENCE_FRAME ref_frames[2] = {ref_frame, second_ref_frame}; 2867 const MV_REFERENCE_FRAME ref_frames[2] = {ref_frame, second_ref_frame};
2839 if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv, 2868 if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv,
2840 inter_mode_mask, this_mode, ref_frames)) 2869 this_mode, ref_frames))
2841 continue; 2870 continue;
2842 } 2871 }
2843 2872
2844 mbmi->mode = this_mode; 2873 mbmi->mode = this_mode;
2845 mbmi->uv_mode = DC_PRED; 2874 mbmi->uv_mode = DC_PRED;
2846 mbmi->ref_frame[0] = ref_frame; 2875 mbmi->ref_frame[0] = ref_frame;
2847 mbmi->ref_frame[1] = second_ref_frame; 2876 mbmi->ref_frame[1] = second_ref_frame;
2848 // Evaluate all sub-pel filters irrespective of whether we can use 2877 // Evaluate all sub-pel filters irrespective of whether we can use
2849 // them for this frame. 2878 // them for this frame.
2850 mbmi->interp_filter = cm->interp_filter == SWITCHABLE ? EIGHTTAP 2879 mbmi->interp_filter = cm->interp_filter == SWITCHABLE ? EIGHTTAP
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
2911 // Estimate the reference frame signaling cost and add it 2940 // Estimate the reference frame signaling cost and add it
2912 // to the rolling cost variable. 2941 // to the rolling cost variable.
2913 if (comp_pred) { 2942 if (comp_pred) {
2914 rate2 += ref_costs_comp[ref_frame]; 2943 rate2 += ref_costs_comp[ref_frame];
2915 } else { 2944 } else {
2916 rate2 += ref_costs_single[ref_frame]; 2945 rate2 += ref_costs_single[ref_frame];
2917 } 2946 }
2918 2947
2919 if (!disable_skip) { 2948 if (!disable_skip) {
2920 if (skippable) { 2949 if (skippable) {
2921 vp9_prob skip_prob = vp9_get_skip_prob(cm, xd);
2922
2923 // Back out the coefficient coding costs 2950 // Back out the coefficient coding costs
2924 rate2 -= (rate_y + rate_uv); 2951 rate2 -= (rate_y + rate_uv);
2925 // for best yrd calculation
2926 rate_uv = 0;
2927 2952
2928 // Cost the skip mb case 2953 // Cost the skip mb case
2929 if (skip_prob) { 2954 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
2930 int prob_skip_cost = vp9_cost_bit(skip_prob, 1);
2931 rate2 += prob_skip_cost;
2932 }
2933 } else if (ref_frame != INTRA_FRAME && !xd->lossless) { 2955 } else if (ref_frame != INTRA_FRAME && !xd->lossless) {
2934 if (RDCOST(x->rdmult, x->rddiv, rate_y + rate_uv, distortion2) < 2956 if (RDCOST(x->rdmult, x->rddiv, rate_y + rate_uv, distortion2) <
2935 RDCOST(x->rdmult, x->rddiv, 0, total_sse)) { 2957 RDCOST(x->rdmult, x->rddiv, 0, total_sse)) {
2936 // Add in the cost of the no skip flag. 2958 // Add in the cost of the no skip flag.
2937 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0); 2959 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
2938 } else { 2960 } else {
2939 // FIXME(rbultje) make this work for splitmv also 2961 // FIXME(rbultje) make this work for splitmv also
2940 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); 2962 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
2941 distortion2 = total_sse; 2963 distortion2 = total_sse;
2942 assert(total_sse >= 0); 2964 assert(total_sse >= 0);
2943 rate2 -= (rate_y + rate_uv); 2965 rate2 -= (rate_y + rate_uv);
2944 rate_y = 0;
2945 rate_uv = 0;
2946 this_skip2 = 1; 2966 this_skip2 = 1;
2947 } 2967 }
2948 } else { 2968 } else {
2949 // Add in the cost of the no skip flag. 2969 // Add in the cost of the no skip flag.
2950 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0); 2970 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
2951 } 2971 }
2952 2972
2953 // Calculate the final RD estimate for this mode. 2973 // Calculate the final RD estimate for this mode.
2954 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 2974 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
2955 } 2975 }
2956 2976
2957 if (ref_frame == INTRA_FRAME) { 2977 if (ref_frame == INTRA_FRAME) {
2958 // Keep record of best intra rd 2978 // Keep record of best intra rd
2959 if (this_rd < best_intra_rd) { 2979 if (this_rd < best_intra_rd) {
2960 best_intra_rd = this_rd; 2980 best_intra_rd = this_rd;
2961 best_intra_mode = mbmi->mode; 2981 best_intra_mode = mbmi->mode;
2962 } 2982 }
2963 } else {
2964 // Keep record of best inter rd with single reference
2965 if (!comp_pred && !mode_excluded && this_rd < best_inter_rd) {
2966 best_inter_rd = this_rd;
2967 best_inter_ref_frame = ref_frame;
2968 }
2969 } 2983 }
2970 2984
2971 if (!disable_skip && ref_frame == INTRA_FRAME) { 2985 if (!disable_skip && ref_frame == INTRA_FRAME) {
2972 for (i = 0; i < REFERENCE_MODES; ++i) 2986 for (i = 0; i < REFERENCE_MODES; ++i)
2973 best_pred_rd[i] = MIN(best_pred_rd[i], this_rd); 2987 best_pred_rd[i] = MIN(best_pred_rd[i], this_rd);
2974 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) 2988 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
2975 best_filter_rd[i] = MIN(best_filter_rd[i], this_rd); 2989 best_filter_rd[i] = MIN(best_filter_rd[i], this_rd);
2976 } 2990 }
2977 2991
2978 // Did this mode help.. i.e. is it the new best mode 2992 // Did this mode help.. i.e. is it the new best mode
2979 if (this_rd < best_rd || x->skip) { 2993 if (this_rd < best_rd || x->skip) {
2980 int max_plane = MAX_MB_PLANE; 2994 int max_plane = MAX_MB_PLANE;
2981 if (!mode_excluded) { 2995 if (!mode_excluded) {
2982 // Note index of best mode so far 2996 // Note index of best mode so far
2983 best_mode_index = mode_index; 2997 best_mode_index = mode_index;
2984 2998
2985 if (ref_frame == INTRA_FRAME) { 2999 if (ref_frame == INTRA_FRAME) {
2986 /* required for left and above block mv */ 3000 /* required for left and above block mv */
2987 mbmi->mv[0].as_int = 0; 3001 mbmi->mv[0].as_int = 0;
2988 max_plane = 1; 3002 max_plane = 1;
2989 } else { 3003 } else {
2990 best_intra_rd = x->pred_sse[ref_frame]; 3004 best_pred_sse = x->pred_sse[ref_frame];
2991 } 3005 }
2992 3006
2993 *returnrate = rate2; 3007 *returnrate = rate2;
2994 *returndistortion = distortion2; 3008 *returndistortion = distortion2;
2995 best_rd = this_rd; 3009 best_rd = this_rd;
2996 best_mbmode = *mbmi; 3010 best_mbmode = *mbmi;
2997 best_skip2 = this_skip2; 3011 best_skip2 = this_skip2;
2998 best_mode_skippable = skippable; 3012 best_mode_skippable = skippable;
2999 3013
3000 if (!x->select_tx_size) 3014 if (!x->select_tx_size)
(...skipping 29 matching lines...) Expand all
3030 hybrid_rate = rate2; 3044 hybrid_rate = rate2;
3031 } else { 3045 } else {
3032 single_rate = rate2; 3046 single_rate = rate2;
3033 hybrid_rate = rate2 + compmode_cost; 3047 hybrid_rate = rate2 + compmode_cost;
3034 } 3048 }
3035 3049
3036 single_rd = RDCOST(x->rdmult, x->rddiv, single_rate, distortion2); 3050 single_rd = RDCOST(x->rdmult, x->rddiv, single_rate, distortion2);
3037 hybrid_rd = RDCOST(x->rdmult, x->rddiv, hybrid_rate, distortion2); 3051 hybrid_rd = RDCOST(x->rdmult, x->rddiv, hybrid_rate, distortion2);
3038 3052
3039 if (!comp_pred) { 3053 if (!comp_pred) {
3040 if (single_rd < best_pred_rd[SINGLE_REFERENCE]) { 3054 if (single_rd < best_pred_rd[SINGLE_REFERENCE])
3041 best_pred_rd[SINGLE_REFERENCE] = single_rd; 3055 best_pred_rd[SINGLE_REFERENCE] = single_rd;
3042 }
3043 } else { 3056 } else {
3044 if (single_rd < best_pred_rd[COMPOUND_REFERENCE]) { 3057 if (single_rd < best_pred_rd[COMPOUND_REFERENCE])
3045 best_pred_rd[COMPOUND_REFERENCE] = single_rd; 3058 best_pred_rd[COMPOUND_REFERENCE] = single_rd;
3046 }
3047 } 3059 }
3048 if (hybrid_rd < best_pred_rd[REFERENCE_MODE_SELECT]) 3060 if (hybrid_rd < best_pred_rd[REFERENCE_MODE_SELECT])
3049 best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd; 3061 best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd;
3050 3062
3051 /* keep record of best filter type */ 3063 /* keep record of best filter type */
3052 if (!mode_excluded && cm->interp_filter != BILINEAR) { 3064 if (!mode_excluded && cm->interp_filter != BILINEAR) {
3053 int64_t ref = rd_opt->filter_cache[cm->interp_filter == SWITCHABLE ? 3065 int64_t ref = rd_opt->filter_cache[cm->interp_filter == SWITCHABLE ?
3054 SWITCHABLE_FILTERS : cm->interp_filter]; 3066 SWITCHABLE_FILTERS : cm->interp_filter];
3055 3067
3056 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) { 3068 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
3117 ((comp_pred_mode && best_mbmode.mv[1].as_int == 0) || !comp_pred_mode)) 3129 ((comp_pred_mode && best_mbmode.mv[1].as_int == 0) || !comp_pred_mode))
3118 best_mbmode.mode = ZEROMV; 3130 best_mbmode.mode = ZEROMV;
3119 } 3131 }
3120 3132
3121 if (best_mode_index < 0 || best_rd >= best_rd_so_far) 3133 if (best_mode_index < 0 || best_rd >= best_rd_so_far)
3122 return INT64_MAX; 3134 return INT64_MAX;
3123 3135
3124 // If we used an estimate for the uv intra rd in the loop above... 3136 // If we used an estimate for the uv intra rd in the loop above...
3125 if (cpi->sf.use_uv_intra_rd_estimate) { 3137 if (cpi->sf.use_uv_intra_rd_estimate) {
3126 // Do Intra UV best rd mode selection if best mode choice above was intra. 3138 // Do Intra UV best rd mode selection if best mode choice above was intra.
3127 if (vp9_mode_order[best_mode_index].ref_frame[0] == INTRA_FRAME) { 3139 if (best_mbmode.ref_frame[0] == INTRA_FRAME) {
3128 TX_SIZE uv_tx_size; 3140 TX_SIZE uv_tx_size;
3129 *mbmi = best_mbmode; 3141 *mbmi = best_mbmode;
3130 uv_tx_size = get_uv_tx_size(mbmi, &xd->plane[1]); 3142 uv_tx_size = get_uv_tx_size(mbmi, &xd->plane[1]);
3131 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv_intra[uv_tx_size], 3143 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv_intra[uv_tx_size],
3132 &rate_uv_tokenonly[uv_tx_size], 3144 &rate_uv_tokenonly[uv_tx_size],
3133 &dist_uv[uv_tx_size], 3145 &dist_uv[uv_tx_size],
3134 &skip_uv[uv_tx_size], 3146 &skip_uv[uv_tx_size],
3135 bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize, 3147 bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize,
3136 uv_tx_size); 3148 uv_tx_size);
3137 } 3149 }
3138 } 3150 }
3139 3151
3140 assert((cm->interp_filter == SWITCHABLE) || 3152 assert((cm->interp_filter == SWITCHABLE) ||
3141 (cm->interp_filter == best_mbmode.interp_filter) || 3153 (cm->interp_filter == best_mbmode.interp_filter) ||
3142 !is_inter_block(&best_mbmode)); 3154 !is_inter_block(&best_mbmode));
3143 3155
3144 update_rd_thresh_fact(cpi, bsize, best_mode_index); 3156 if (!cpi->rc.is_src_frame_alt_ref)
3157 update_rd_thresh_fact(cpi, bsize, best_mode_index);
3145 3158
3146 // macroblock modes 3159 // macroblock modes
3147 *mbmi = best_mbmode; 3160 *mbmi = best_mbmode;
3148 x->skip |= best_skip2; 3161 x->skip |= best_skip2;
3149 3162
3150 for (i = 0; i < REFERENCE_MODES; ++i) { 3163 for (i = 0; i < REFERENCE_MODES; ++i) {
3151 if (best_pred_rd[i] == INT64_MAX) 3164 if (best_pred_rd[i] == INT64_MAX)
3152 best_pred_diff[i] = INT_MIN; 3165 best_pred_diff[i] = INT_MIN;
3153 else 3166 else
3154 best_pred_diff[i] = best_rd - best_pred_rd[i]; 3167 best_pred_diff[i] = best_rd - best_pred_rd[i];
(...skipping 12 matching lines...) Expand all
3167 if (best_tx_rd[i] == INT64_MAX) 3180 if (best_tx_rd[i] == INT64_MAX)
3168 best_tx_diff[i] = 0; 3181 best_tx_diff[i] = 0;
3169 else 3182 else
3170 best_tx_diff[i] = best_rd - best_tx_rd[i]; 3183 best_tx_diff[i] = best_rd - best_tx_rd[i];
3171 } 3184 }
3172 } else { 3185 } else {
3173 vp9_zero(best_filter_diff); 3186 vp9_zero(best_filter_diff);
3174 vp9_zero(best_tx_diff); 3187 vp9_zero(best_tx_diff);
3175 } 3188 }
3176 3189
3177 set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); 3190 // TODO(yunqingwang): Moving this line in front of the above best_filter_diff
3191 // updating code causes PSNR loss. Need to figure out the confliction.
3192 x->skip |= best_mode_skippable;
3193
3178 store_coding_context(x, ctx, best_mode_index, best_pred_diff, 3194 store_coding_context(x, ctx, best_mode_index, best_pred_diff,
3179 best_tx_diff, best_filter_diff, best_mode_skippable); 3195 best_tx_diff, best_filter_diff, best_mode_skippable);
3180 3196
3181 return best_rd; 3197 return best_rd;
3182 } 3198 }
3183 3199
3184 int64_t vp9_rd_pick_inter_mode_sb_seg_skip(VP9_COMP *cpi, MACROBLOCK *x, 3200 int64_t vp9_rd_pick_inter_mode_sb_seg_skip(VP9_COMP *cpi, MACROBLOCK *x,
3185 int *returnrate, 3201 int *returnrate,
3186 int64_t *returndistortion, 3202 int64_t *returndistortion,
3187 BLOCK_SIZE bsize, 3203 BLOCK_SIZE bsize,
3188 PICK_MODE_CONTEXT *ctx, 3204 PICK_MODE_CONTEXT *ctx,
3189 int64_t best_rd_so_far) { 3205 int64_t best_rd_so_far) {
3190 VP9_COMMON *const cm = &cpi->common; 3206 VP9_COMMON *const cm = &cpi->common;
3191 RD_OPT *const rd_opt = &cpi->rd; 3207 RD_OPT *const rd_opt = &cpi->rd;
3192 MACROBLOCKD *const xd = &x->e_mbd; 3208 MACROBLOCKD *const xd = &x->e_mbd;
3193 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 3209 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
3194 unsigned char segment_id = mbmi->segment_id; 3210 unsigned char segment_id = mbmi->segment_id;
3195 const int comp_pred = 0; 3211 const int comp_pred = 0;
3196 int i; 3212 int i;
3197 int64_t best_tx_diff[TX_MODES]; 3213 int64_t best_tx_diff[TX_MODES];
3198 int64_t best_pred_diff[REFERENCE_MODES]; 3214 int64_t best_pred_diff[REFERENCE_MODES];
3199 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS]; 3215 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
3200 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES]; 3216 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
3201 vp9_prob comp_mode_p; 3217 vp9_prob comp_mode_p;
3202 INTERP_FILTER best_filter = SWITCHABLE; 3218 INTERP_FILTER best_filter = SWITCHABLE;
3203 int64_t this_rd = INT64_MAX; 3219 int64_t this_rd = INT64_MAX;
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after
3290 const TileInfo *const tile, 3306 const TileInfo *const tile,
3291 int mi_row, int mi_col, 3307 int mi_row, int mi_col,
3292 int *returnrate, 3308 int *returnrate,
3293 int64_t *returndistortion, 3309 int64_t *returndistortion,
3294 BLOCK_SIZE bsize, 3310 BLOCK_SIZE bsize,
3295 PICK_MODE_CONTEXT *ctx, 3311 PICK_MODE_CONTEXT *ctx,
3296 int64_t best_rd_so_far) { 3312 int64_t best_rd_so_far) {
3297 VP9_COMMON *const cm = &cpi->common; 3313 VP9_COMMON *const cm = &cpi->common;
3298 RD_OPT *const rd_opt = &cpi->rd; 3314 RD_OPT *const rd_opt = &cpi->rd;
3299 MACROBLOCKD *const xd = &x->e_mbd; 3315 MACROBLOCKD *const xd = &x->e_mbd;
3300 MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 3316 MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
3301 const struct segmentation *const seg = &cm->seg; 3317 const struct segmentation *const seg = &cm->seg;
3302 MV_REFERENCE_FRAME ref_frame, second_ref_frame; 3318 MV_REFERENCE_FRAME ref_frame, second_ref_frame;
3303 unsigned char segment_id = mbmi->segment_id; 3319 unsigned char segment_id = mbmi->segment_id;
3304 int comp_pred, i; 3320 int comp_pred, i;
3305 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; 3321 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
3306 struct buf_2d yv12_mb[4][MAX_MB_PLANE]; 3322 struct buf_2d yv12_mb[4][MAX_MB_PLANE];
3307 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, 3323 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
3308 VP9_ALT_FLAG }; 3324 VP9_ALT_FLAG };
3309 int64_t best_rd = best_rd_so_far; 3325 int64_t best_rd = best_rd_so_far;
3310 int64_t best_yrd = best_rd_so_far; // FIXME(rbultje) more precise 3326 int64_t best_yrd = best_rd_so_far; // FIXME(rbultje) more precise
3311 static const int64_t best_tx_diff[TX_MODES] = { 0 }; 3327 static const int64_t best_tx_diff[TX_MODES] = { 0 };
3312 int64_t best_pred_diff[REFERENCE_MODES]; 3328 int64_t best_pred_diff[REFERENCE_MODES];
3313 int64_t best_pred_rd[REFERENCE_MODES]; 3329 int64_t best_pred_rd[REFERENCE_MODES];
3314 int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS]; 3330 int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
3315 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS]; 3331 int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
3316 MB_MODE_INFO best_mbmode; 3332 MB_MODE_INFO best_mbmode;
3317 int ref_index, best_ref_index = 0; 3333 int ref_index, best_ref_index = 0;
3318 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES]; 3334 unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
3319 vp9_prob comp_mode_p; 3335 vp9_prob comp_mode_p;
3320 int64_t best_inter_rd = INT64_MAX;
3321 MV_REFERENCE_FRAME best_inter_ref_frame = LAST_FRAME;
3322 INTERP_FILTER tmp_best_filter = SWITCHABLE; 3336 INTERP_FILTER tmp_best_filter = SWITCHABLE;
3323 int rate_uv_intra, rate_uv_tokenonly; 3337 int rate_uv_intra, rate_uv_tokenonly;
3324 int64_t dist_uv; 3338 int64_t dist_uv;
3325 int skip_uv; 3339 int skip_uv;
3326 PREDICTION_MODE mode_uv = DC_PRED; 3340 PREDICTION_MODE mode_uv = DC_PRED;
3327 int intra_cost_penalty = 20 * vp9_dc_quant(cm->base_qindex, cm->y_dc_delta_q); 3341 const int intra_cost_penalty =
3342 20 * vp9_dc_quant(cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth);
3328 int_mv seg_mvs[4][MAX_REF_FRAMES]; 3343 int_mv seg_mvs[4][MAX_REF_FRAMES];
3329 b_mode_info best_bmodes[4]; 3344 b_mode_info best_bmodes[4];
3330 int best_skip2 = 0; 3345 int best_skip2 = 0;
3331 int mode_skip_mask = 0; 3346 int ref_frame_skip_mask[2] = { 0 };
3332 3347
3333 x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; 3348 x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
3334 vpx_memset(x->zcoeff_blk[TX_4X4], 0, 4); 3349 vpx_memset(x->zcoeff_blk[TX_4X4], 0, 4);
3335 vp9_zero(best_mbmode); 3350 vp9_zero(best_mbmode);
3336 3351
3337 for (i = 0; i < 4; i++) { 3352 for (i = 0; i < 4; i++) {
3338 int j; 3353 int j;
3339 for (j = 0; j < MAX_REF_FRAMES; j++) 3354 for (j = 0; j < MAX_REF_FRAMES; j++)
3340 seg_mvs[i][j].as_int = INVALID_MV; 3355 seg_mvs[i][j].as_int = INVALID_MV;
3341 } 3356 }
3342 3357
3343 estimate_ref_frame_costs(cm, xd, segment_id, ref_costs_single, ref_costs_comp, 3358 estimate_ref_frame_costs(cm, xd, segment_id, ref_costs_single, ref_costs_comp,
3344 &comp_mode_p); 3359 &comp_mode_p);
3345 3360
3346 for (i = 0; i < REFERENCE_MODES; ++i) 3361 for (i = 0; i < REFERENCE_MODES; ++i)
3347 best_pred_rd[i] = INT64_MAX; 3362 best_pred_rd[i] = INT64_MAX;
3348 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) 3363 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
3349 best_filter_rd[i] = INT64_MAX; 3364 best_filter_rd[i] = INT64_MAX;
3350 rate_uv_intra = INT_MAX; 3365 rate_uv_intra = INT_MAX;
3351 3366
3352 *returnrate = INT_MAX; 3367 *returnrate = INT_MAX;
3353 3368
3354 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { 3369 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
3355 if (cpi->ref_frame_flags & flag_list[ref_frame]) { 3370 if (cpi->ref_frame_flags & flag_list[ref_frame]) {
3356 setup_buffer_inter(cpi, x, tile, 3371 setup_buffer_inter(cpi, x, tile,
3357 ref_frame, bsize, mi_row, mi_col, 3372 ref_frame, bsize, mi_row, mi_col,
3358 frame_mv[NEARESTMV], frame_mv[NEARMV], 3373 frame_mv[NEARESTMV], frame_mv[NEARMV],
3359 yv12_mb); 3374 yv12_mb);
3375 } else {
3376 ref_frame_skip_mask[0] |= (1 << ref_frame);
3377 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
3360 } 3378 }
3361 frame_mv[NEWMV][ref_frame].as_int = INVALID_MV; 3379 frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
3362 frame_mv[ZEROMV][ref_frame].as_int = 0; 3380 frame_mv[ZEROMV][ref_frame].as_int = 0;
3363 } 3381 }
3364 3382
3365 for (ref_index = 0; ref_index < MAX_REFS; ++ref_index) { 3383 for (ref_index = 0; ref_index < MAX_REFS; ++ref_index) {
3366 int mode_excluded = 0; 3384 int mode_excluded = 0;
3367 int64_t this_rd = INT64_MAX; 3385 int64_t this_rd = INT64_MAX;
3368 int disable_skip = 0; 3386 int disable_skip = 0;
3369 int compmode_cost = 0; 3387 int compmode_cost = 0;
3370 int rate2 = 0, rate_y = 0, rate_uv = 0; 3388 int rate2 = 0, rate_y = 0, rate_uv = 0;
3371 int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0; 3389 int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
3372 int skippable = 0; 3390 int skippable = 0;
3373 int i; 3391 int i;
3374 int this_skip2 = 0; 3392 int this_skip2 = 0;
3375 int64_t total_sse = INT_MAX; 3393 int64_t total_sse = INT_MAX;
3376 int early_term = 0; 3394 int early_term = 0;
3377 3395
3378 ref_frame = vp9_ref_order[ref_index].ref_frame[0]; 3396 ref_frame = vp9_ref_order[ref_index].ref_frame[0];
3379 second_ref_frame = vp9_ref_order[ref_index].ref_frame[1]; 3397 second_ref_frame = vp9_ref_order[ref_index].ref_frame[1];
3380 3398
3381 // Look at the reference frame of the best mode so far and set the 3399 // Look at the reference frame of the best mode so far and set the
3382 // skip mask to look at a subset of the remaining modes. 3400 // skip mask to look at a subset of the remaining modes.
3383 if (ref_index > 2 && cpi->sf.mode_skip_start < MAX_MODES) { 3401 if (ref_index > 2 && cpi->sf.mode_skip_start < MAX_MODES) {
3384 if (ref_index == 3) { 3402 if (ref_index == 3) {
3385 switch (vp9_ref_order[best_ref_index].ref_frame[0]) { 3403 switch (best_mbmode.ref_frame[0]) {
3386 case INTRA_FRAME: 3404 case INTRA_FRAME:
3387 mode_skip_mask = 0;
3388 break; 3405 break;
3389 case LAST_FRAME: 3406 case LAST_FRAME:
3390 mode_skip_mask = 0x0010; 3407 ref_frame_skip_mask[0] |= (1 << GOLDEN_FRAME) | (1 << ALTREF_FRAME);
3408 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
3391 break; 3409 break;
3392 case GOLDEN_FRAME: 3410 case GOLDEN_FRAME:
3393 mode_skip_mask = 0x0008; 3411 ref_frame_skip_mask[0] |= (1 << LAST_FRAME) | (1 << ALTREF_FRAME);
3412 ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
3394 break; 3413 break;
3395 case ALTREF_FRAME: 3414 case ALTREF_FRAME:
3396 mode_skip_mask = 0x0000; 3415 ref_frame_skip_mask[0] |= (1 << GOLDEN_FRAME) | (1 << LAST_FRAME);
3397 break; 3416 break;
3398 case NONE: 3417 case NONE:
3399 case MAX_REF_FRAMES: 3418 case MAX_REF_FRAMES:
3400 assert(0 && "Invalid Reference frame"); 3419 assert(0 && "Invalid Reference frame");
3401 break; 3420 break;
3402 } 3421 }
3403 } 3422 }
3404 if (mode_skip_mask & (1 << ref_index))
3405 continue;
3406 } 3423 }
3407 3424
3425 if (ref_frame_skip_mask[0] & (1 << ref_frame) &&
3426 ref_frame_skip_mask[1] & (1 << MAX(0, second_ref_frame)))
3427 continue;
3428
3408 // Test best rd so far against threshold for trying this mode. 3429 // Test best rd so far against threshold for trying this mode.
3409 if (rd_less_than_thresh(best_rd, 3430 if (rd_less_than_thresh(best_rd,
3410 rd_opt->threshes[segment_id][bsize][ref_index], 3431 rd_opt->threshes[segment_id][bsize][ref_index],
3411 rd_opt->thresh_freq_fact[bsize][ref_index])) 3432 rd_opt->thresh_freq_fact[bsize][ref_index]))
3412 continue; 3433 continue;
3413 3434
3414 if (ref_frame > INTRA_FRAME &&
3415 !(cpi->ref_frame_flags & flag_list[ref_frame])) {
3416 continue;
3417 }
3418
3419 comp_pred = second_ref_frame > INTRA_FRAME; 3435 comp_pred = second_ref_frame > INTRA_FRAME;
3420 if (comp_pred) { 3436 if (comp_pred) {
3421 if (!cm->allow_comp_inter_inter) 3437 if (!cm->allow_comp_inter_inter)
3422 continue; 3438 continue;
3423
3424 if (!(cpi->ref_frame_flags & flag_list[second_ref_frame])) 3439 if (!(cpi->ref_frame_flags & flag_list[second_ref_frame]))
3425 continue; 3440 continue;
3426 // Do not allow compound prediction if the segment level reference frame 3441 // Do not allow compound prediction if the segment level reference frame
3427 // feature is in use as in this case there can only be one reference. 3442 // feature is in use as in this case there can only be one reference.
3428 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) 3443 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
3429 continue; 3444 continue;
3445
3430 if ((cpi->sf.mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA) && 3446 if ((cpi->sf.mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA) &&
3431 vp9_ref_order[best_ref_index].ref_frame[0] == INTRA_FRAME) 3447 best_mbmode.ref_frame[0] == INTRA_FRAME)
3432 continue;
3433 if ((cpi->sf.mode_search_skip_flags & FLAG_SKIP_COMP_REFMISMATCH) &&
3434 ref_frame != best_inter_ref_frame &&
3435 second_ref_frame != best_inter_ref_frame)
3436 continue; 3448 continue;
3437 } 3449 }
3438 3450
3439 // TODO(jingning, jkoleszar): scaling reference frame not supported for 3451 // TODO(jingning, jkoleszar): scaling reference frame not supported for
3440 // sub8x8 blocks. 3452 // sub8x8 blocks.
3441 if (ref_frame > INTRA_FRAME && 3453 if (ref_frame > INTRA_FRAME &&
3442 vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf)) 3454 vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf))
3443 continue; 3455 continue;
3444 3456
3445 if (second_ref_frame > INTRA_FRAME && 3457 if (second_ref_frame > INTRA_FRAME &&
3446 vp9_is_scaled(&cm->frame_refs[second_ref_frame - 1].sf)) 3458 vp9_is_scaled(&cm->frame_refs[second_ref_frame - 1].sf))
3447 continue; 3459 continue;
3448 3460
3449 if (comp_pred) 3461 if (comp_pred)
3450 mode_excluded = cm->reference_mode == SINGLE_REFERENCE; 3462 mode_excluded = cm->reference_mode == SINGLE_REFERENCE;
3451 else if (ref_frame != INTRA_FRAME) 3463 else if (ref_frame != INTRA_FRAME)
3452 mode_excluded = cm->reference_mode == COMPOUND_REFERENCE; 3464 mode_excluded = cm->reference_mode == COMPOUND_REFERENCE;
3453 3465
3454 // If the segment reference frame feature is enabled.... 3466 // If the segment reference frame feature is enabled....
3455 // then do nothing if the current ref frame is not allowed.. 3467 // then do nothing if the current ref frame is not allowed..
3456 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) && 3468 if (vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
3457 vp9_get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != 3469 vp9_get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) {
3458 (int)ref_frame) {
3459 continue; 3470 continue;
3460 // Disable this drop out case if the ref frame 3471 // Disable this drop out case if the ref frame
3461 // segment level feature is enabled for this segment. This is to 3472 // segment level feature is enabled for this segment. This is to
3462 // prevent the possibility that we end up unable to pick any mode. 3473 // prevent the possibility that we end up unable to pick any mode.
3463 } else if (!vp9_segfeature_active(seg, segment_id, 3474 } else if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) {
3464 SEG_LVL_REF_FRAME)) {
3465 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame, 3475 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
3466 // unless ARNR filtering is enabled in which case we want 3476 // unless ARNR filtering is enabled in which case we want
3467 // an unfiltered alternative. We allow near/nearest as well 3477 // an unfiltered alternative. We allow near/nearest as well
3468 // because they may result in zero-zero MVs but be cheaper. 3478 // because they may result in zero-zero MVs but be cheaper.
3469 if (cpi->rc.is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) 3479 if (cpi->rc.is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
3470 continue; 3480 continue;
3471 } 3481 }
3472 3482
3473 mbmi->tx_size = TX_4X4; 3483 mbmi->tx_size = TX_4X4;
3474 mbmi->uv_mode = DC_PRED; 3484 mbmi->uv_mode = DC_PRED;
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after
3583 (mbmi->interp_filter == cm->interp_filter && 3593 (mbmi->interp_filter == cm->interp_filter &&
3584 cm->interp_filter != SWITCHABLE)) { 3594 cm->interp_filter != SWITCHABLE)) {
3585 tmp_best_rdu = tmp_rd; 3595 tmp_best_rdu = tmp_rd;
3586 tmp_best_rate = rate; 3596 tmp_best_rate = rate;
3587 tmp_best_ratey = rate_y; 3597 tmp_best_ratey = rate_y;
3588 tmp_best_distortion = distortion; 3598 tmp_best_distortion = distortion;
3589 tmp_best_sse = total_sse; 3599 tmp_best_sse = total_sse;
3590 tmp_best_skippable = skippable; 3600 tmp_best_skippable = skippable;
3591 tmp_best_mbmode = *mbmi; 3601 tmp_best_mbmode = *mbmi;
3592 for (i = 0; i < 4; i++) { 3602 for (i = 0; i < 4; i++) {
3593 tmp_best_bmodes[i] = xd->mi[0]->bmi[i]; 3603 tmp_best_bmodes[i] = xd->mi[0].src_mi->bmi[i];
3594 x->zcoeff_blk[TX_4X4][i] = !x->plane[0].eobs[i]; 3604 x->zcoeff_blk[TX_4X4][i] = !x->plane[0].eobs[i];
3595 } 3605 }
3596 pred_exists = 1; 3606 pred_exists = 1;
3597 if (switchable_filter_index == 0 && 3607 if (switchable_filter_index == 0 &&
3598 cpi->sf.use_rd_breakout && 3608 cpi->sf.use_rd_breakout &&
3599 best_rd < INT64_MAX) { 3609 best_rd < INT64_MAX) {
3600 if (tmp_best_rdu / 2 > best_rd) { 3610 if (tmp_best_rdu / 2 > best_rd) {
3601 // skip searching the other filters if the first is 3611 // skip searching the other filters if the first is
3602 // already substantially larger than the best so far 3612 // already substantially larger than the best so far
3603 tmp_best_filter = mbmi->interp_filter; 3613 tmp_best_filter = mbmi->interp_filter;
(...skipping 23 matching lines...) Expand all
3627 if (tmp_rd == INT64_MAX) 3637 if (tmp_rd == INT64_MAX)
3628 continue; 3638 continue;
3629 } else { 3639 } else {
3630 total_sse = tmp_best_sse; 3640 total_sse = tmp_best_sse;
3631 rate = tmp_best_rate; 3641 rate = tmp_best_rate;
3632 rate_y = tmp_best_ratey; 3642 rate_y = tmp_best_ratey;
3633 distortion = tmp_best_distortion; 3643 distortion = tmp_best_distortion;
3634 skippable = tmp_best_skippable; 3644 skippable = tmp_best_skippable;
3635 *mbmi = tmp_best_mbmode; 3645 *mbmi = tmp_best_mbmode;
3636 for (i = 0; i < 4; i++) 3646 for (i = 0; i < 4; i++)
3637 xd->mi[0]->bmi[i] = tmp_best_bmodes[i]; 3647 xd->mi[0].src_mi->bmi[i] = tmp_best_bmodes[i];
3638 } 3648 }
3639 3649
3640 rate2 += rate; 3650 rate2 += rate;
3641 distortion2 += distortion; 3651 distortion2 += distortion;
3642 3652
3643 if (cm->interp_filter == SWITCHABLE) 3653 if (cm->interp_filter == SWITCHABLE)
3644 rate2 += vp9_get_switchable_rate(cpi); 3654 rate2 += vp9_get_switchable_rate(cpi);
3645 3655
3646 if (!mode_excluded) 3656 if (!mode_excluded)
3647 mode_excluded = comp_pred ? cm->reference_mode == SINGLE_REFERENCE 3657 mode_excluded = comp_pred ? cm->reference_mode == SINGLE_REFERENCE
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
3701 } 3711 }
3702 } else { 3712 } else {
3703 // Add in the cost of the no skip flag. 3713 // Add in the cost of the no skip flag.
3704 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0); 3714 rate2 += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
3705 } 3715 }
3706 3716
3707 // Calculate the final RD estimate for this mode. 3717 // Calculate the final RD estimate for this mode.
3708 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 3718 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
3709 } 3719 }
3710 3720
3711 // Keep record of best inter rd with single reference
3712 if (is_inter_block(mbmi) &&
3713 !has_second_ref(mbmi) &&
3714 !mode_excluded &&
3715 this_rd < best_inter_rd) {
3716 best_inter_rd = this_rd;
3717 best_inter_ref_frame = ref_frame;
3718 }
3719
3720 if (!disable_skip && ref_frame == INTRA_FRAME) { 3721 if (!disable_skip && ref_frame == INTRA_FRAME) {
3721 for (i = 0; i < REFERENCE_MODES; ++i) 3722 for (i = 0; i < REFERENCE_MODES; ++i)
3722 best_pred_rd[i] = MIN(best_pred_rd[i], this_rd); 3723 best_pred_rd[i] = MIN(best_pred_rd[i], this_rd);
3723 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) 3724 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
3724 best_filter_rd[i] = MIN(best_filter_rd[i], this_rd); 3725 best_filter_rd[i] = MIN(best_filter_rd[i], this_rd);
3725 } 3726 }
3726 3727
3727 // Did this mode help.. i.e. is it the new best mode 3728 // Did this mode help.. i.e. is it the new best mode
3728 if (this_rd < best_rd || x->skip) { 3729 if (this_rd < best_rd || x->skip) {
3729 if (!mode_excluded) { 3730 if (!mode_excluded) {
(...skipping 13 matching lines...) Expand all
3743 best_yrd = best_rd - 3744 best_yrd = best_rd -
3744 RDCOST(x->rdmult, x->rddiv, rate_uv, distortion_uv); 3745 RDCOST(x->rdmult, x->rddiv, rate_uv, distortion_uv);
3745 best_mbmode = *mbmi; 3746 best_mbmode = *mbmi;
3746 best_skip2 = this_skip2; 3747 best_skip2 = this_skip2;
3747 if (!x->select_tx_size) 3748 if (!x->select_tx_size)
3748 swap_block_ptr(x, ctx, 1, 0, 0, max_plane); 3749 swap_block_ptr(x, ctx, 1, 0, 0, max_plane);
3749 vpx_memcpy(ctx->zcoeff_blk, x->zcoeff_blk[TX_4X4], 3750 vpx_memcpy(ctx->zcoeff_blk, x->zcoeff_blk[TX_4X4],
3750 sizeof(uint8_t) * ctx->num_4x4_blk); 3751 sizeof(uint8_t) * ctx->num_4x4_blk);
3751 3752
3752 for (i = 0; i < 4; i++) 3753 for (i = 0; i < 4; i++)
3753 best_bmodes[i] = xd->mi[0]->bmi[i]; 3754 best_bmodes[i] = xd->mi[0].src_mi->bmi[i];
3754 3755
3755 // TODO(debargha): enhance this test with a better distortion prediction 3756 // TODO(debargha): enhance this test with a better distortion prediction
3756 // based on qp, activity mask and history 3757 // based on qp, activity mask and history
3757 if ((cpi->sf.mode_search_skip_flags & FLAG_EARLY_TERMINATE) && 3758 if ((cpi->sf.mode_search_skip_flags & FLAG_EARLY_TERMINATE) &&
3758 (ref_index > MIN_EARLY_TERM_INDEX)) { 3759 (ref_index > MIN_EARLY_TERM_INDEX)) {
3759 const int qstep = xd->plane[0].dequant[1]; 3760 const int qstep = xd->plane[0].dequant[1];
3760 // TODO(debargha): Enhance this by specializing for each mode_index 3761 // TODO(debargha): Enhance this by specializing for each mode_index
3761 int scale = 4; 3762 int scale = 4;
3762 if (x->source_variance < UINT_MAX) { 3763 if (x->source_variance < UINT_MAX) {
3763 const int var_adjust = (x->source_variance < 16); 3764 const int var_adjust = (x->source_variance < 16);
(...skipping 15 matching lines...) Expand all
3779 single_rate = rate2 - compmode_cost; 3780 single_rate = rate2 - compmode_cost;
3780 hybrid_rate = rate2; 3781 hybrid_rate = rate2;
3781 } else { 3782 } else {
3782 single_rate = rate2; 3783 single_rate = rate2;
3783 hybrid_rate = rate2 + compmode_cost; 3784 hybrid_rate = rate2 + compmode_cost;
3784 } 3785 }
3785 3786
3786 single_rd = RDCOST(x->rdmult, x->rddiv, single_rate, distortion2); 3787 single_rd = RDCOST(x->rdmult, x->rddiv, single_rate, distortion2);
3787 hybrid_rd = RDCOST(x->rdmult, x->rddiv, hybrid_rate, distortion2); 3788 hybrid_rd = RDCOST(x->rdmult, x->rddiv, hybrid_rate, distortion2);
3788 3789
3789 if (!comp_pred && single_rd < best_pred_rd[SINGLE_REFERENCE]) { 3790 if (!comp_pred && single_rd < best_pred_rd[SINGLE_REFERENCE])
3790 best_pred_rd[SINGLE_REFERENCE] = single_rd; 3791 best_pred_rd[SINGLE_REFERENCE] = single_rd;
3791 } else if (comp_pred && single_rd < best_pred_rd[COMPOUND_REFERENCE]) { 3792 else if (comp_pred && single_rd < best_pred_rd[COMPOUND_REFERENCE])
3792 best_pred_rd[COMPOUND_REFERENCE] = single_rd; 3793 best_pred_rd[COMPOUND_REFERENCE] = single_rd;
3793 } 3794
3794 if (hybrid_rd < best_pred_rd[REFERENCE_MODE_SELECT]) 3795 if (hybrid_rd < best_pred_rd[REFERENCE_MODE_SELECT])
3795 best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd; 3796 best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd;
3796 } 3797 }
3797 3798
3798 /* keep record of best filter type */ 3799 /* keep record of best filter type */
3799 if (!mode_excluded && !disable_skip && ref_frame != INTRA_FRAME && 3800 if (!mode_excluded && !disable_skip && ref_frame != INTRA_FRAME &&
3800 cm->interp_filter != BILINEAR) { 3801 cm->interp_filter != BILINEAR) {
3801 int64_t ref = rd_opt->filter_cache[cm->interp_filter == SWITCHABLE ? 3802 int64_t ref = rd_opt->filter_cache[cm->interp_filter == SWITCHABLE ?
3802 SWITCHABLE_FILTERS : cm->interp_filter]; 3803 SWITCHABLE_FILTERS : cm->interp_filter];
3803 int64_t adj_rd; 3804 int64_t adj_rd;
(...skipping 20 matching lines...) Expand all
3824 if (x->skip && !comp_pred) 3825 if (x->skip && !comp_pred)
3825 break; 3826 break;
3826 } 3827 }
3827 3828
3828 if (best_rd >= best_rd_so_far) 3829 if (best_rd >= best_rd_so_far)
3829 return INT64_MAX; 3830 return INT64_MAX;
3830 3831
3831 // If we used an estimate for the uv intra rd in the loop above... 3832 // If we used an estimate for the uv intra rd in the loop above...
3832 if (cpi->sf.use_uv_intra_rd_estimate) { 3833 if (cpi->sf.use_uv_intra_rd_estimate) {
3833 // Do Intra UV best rd mode selection if best mode choice above was intra. 3834 // Do Intra UV best rd mode selection if best mode choice above was intra.
3834 if (vp9_ref_order[best_ref_index].ref_frame[0] == INTRA_FRAME) { 3835 if (best_mbmode.ref_frame[0] == INTRA_FRAME) {
3835 *mbmi = best_mbmode; 3836 *mbmi = best_mbmode;
3836 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv_intra, 3837 rd_pick_intra_sbuv_mode(cpi, x, ctx, &rate_uv_intra,
3837 &rate_uv_tokenonly, 3838 &rate_uv_tokenonly,
3838 &dist_uv, 3839 &dist_uv,
3839 &skip_uv, 3840 &skip_uv,
3840 BLOCK_8X8, TX_4X4); 3841 BLOCK_8X8, TX_4X4);
3841 } 3842 }
3842 } 3843 }
3843 3844
3844 if (best_rd == INT64_MAX) { 3845 if (best_rd == INT64_MAX) {
3845 *returnrate = INT_MAX; 3846 *returnrate = INT_MAX;
3846 *returndistortion = INT64_MAX; 3847 *returndistortion = INT64_MAX;
3847 return best_rd; 3848 return best_rd;
3848 } 3849 }
3849 3850
3850 assert((cm->interp_filter == SWITCHABLE) || 3851 assert((cm->interp_filter == SWITCHABLE) ||
3851 (cm->interp_filter == best_mbmode.interp_filter) || 3852 (cm->interp_filter == best_mbmode.interp_filter) ||
3852 !is_inter_block(&best_mbmode)); 3853 !is_inter_block(&best_mbmode));
3853 3854
3854 update_rd_thresh_fact(cpi, bsize, best_ref_index); 3855 update_rd_thresh_fact(cpi, bsize, best_ref_index);
3855 3856
3856 // macroblock modes 3857 // macroblock modes
3857 *mbmi = best_mbmode; 3858 *mbmi = best_mbmode;
3858 x->skip |= best_skip2; 3859 x->skip |= best_skip2;
3859 if (!is_inter_block(&best_mbmode)) { 3860 if (!is_inter_block(&best_mbmode)) {
3860 for (i = 0; i < 4; i++) 3861 for (i = 0; i < 4; i++)
3861 xd->mi[0]->bmi[i].as_mode = best_bmodes[i].as_mode; 3862 xd->mi[0].src_mi->bmi[i].as_mode = best_bmodes[i].as_mode;
3862 } else { 3863 } else {
3863 for (i = 0; i < 4; ++i) 3864 for (i = 0; i < 4; ++i)
3864 vpx_memcpy(&xd->mi[0]->bmi[i], &best_bmodes[i], sizeof(b_mode_info)); 3865 vpx_memcpy(&xd->mi[0].src_mi->bmi[i], &best_bmodes[i],
3866 sizeof(b_mode_info));
3865 3867
3866 mbmi->mv[0].as_int = xd->mi[0]->bmi[3].as_mv[0].as_int; 3868 mbmi->mv[0].as_int = xd->mi[0].src_mi->bmi[3].as_mv[0].as_int;
3867 mbmi->mv[1].as_int = xd->mi[0]->bmi[3].as_mv[1].as_int; 3869 mbmi->mv[1].as_int = xd->mi[0].src_mi->bmi[3].as_mv[1].as_int;
3868 } 3870 }
3869 3871
3870 for (i = 0; i < REFERENCE_MODES; ++i) { 3872 for (i = 0; i < REFERENCE_MODES; ++i) {
3871 if (best_pred_rd[i] == INT64_MAX) 3873 if (best_pred_rd[i] == INT64_MAX)
3872 best_pred_diff[i] = INT_MIN; 3874 best_pred_diff[i] = INT_MIN;
3873 else 3875 else
3874 best_pred_diff[i] = best_rd - best_pred_rd[i]; 3876 best_pred_diff[i] = best_rd - best_pred_rd[i];
3875 } 3877 }
3876 3878
3877 if (!x->skip) { 3879 if (!x->skip) {
3878 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) { 3880 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
3879 if (best_filter_rd[i] == INT64_MAX) 3881 if (best_filter_rd[i] == INT64_MAX)
3880 best_filter_diff[i] = 0; 3882 best_filter_diff[i] = 0;
3881 else 3883 else
3882 best_filter_diff[i] = best_rd - best_filter_rd[i]; 3884 best_filter_diff[i] = best_rd - best_filter_rd[i];
3883 } 3885 }
3884 if (cm->interp_filter == SWITCHABLE) 3886 if (cm->interp_filter == SWITCHABLE)
3885 assert(best_filter_diff[SWITCHABLE_FILTERS] == 0); 3887 assert(best_filter_diff[SWITCHABLE_FILTERS] == 0);
3886 } else { 3888 } else {
3887 vp9_zero(best_filter_diff); 3889 vp9_zero(best_filter_diff);
3888 } 3890 }
3889 3891
3890 set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
3891 store_coding_context(x, ctx, best_ref_index, 3892 store_coding_context(x, ctx, best_ref_index,
3892 best_pred_diff, best_tx_diff, best_filter_diff, 0); 3893 best_pred_diff, best_tx_diff, best_filter_diff, 0);
3893 3894
3894 return best_rd; 3895 return best_rd;
3895 } 3896 }
3897
OLDNEW
« no previous file with comments | « source/libvpx/vp9/encoder/vp9_rd.c ('k') | source/libvpx/vp9/encoder/vp9_sad.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698