1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <assert.h>
12 #include <stdio.h>
13 #include <math.h>
14 #include <limits.h>
15 #include <assert.h>
16 #include "vpx_config.h"
17 #include "vp8_rtcd.h"
18 #include "./vpx_dsp_rtcd.h"
19 #include "tokenize.h"
20 #include "treewriter.h"
21 #include "onyx_int.h"
22 #include "modecosts.h"
23 #include "encodeintra.h"
24 #include "pickinter.h"
25 #include "vp8/common/entropymode.h"
26 #include "vp8/common/reconinter.h"
27 #include "vp8/common/reconintra.h"
28 #include "vp8/common/reconintra4x4.h"
29 #include "vp8/common/findnearmv.h"
30 #include "vp8/common/quant_common.h"
31 #include "encodemb.h"
32 #include "vp8/encoder/quantize.h"
33 #include "vpx_dsp/variance.h"
34 #include "vpx_ports/system_state.h"
35 #include "mcomp.h"
36 #include "rdopt.h"
37 #include "vpx_mem/vpx_mem.h"
38 #include "vp8/common/systemdependent.h"
39 #if CONFIG_TEMPORAL_DENOISING
40 #include "denoising.h"
41 #endif
42 extern void vp8_update_zbin_extra(VP8_COMP *cpi, MACROBLOCK *x);
43
44 #define MAXF(a, b) (((a) > (b)) ? (a) : (b))
45
46 typedef struct rate_distortion_struct {
47 int rate2;
48 int rate_y;
49 int rate_uv;
50 int distortion2;
51 int distortion_uv;
52 } RATE_DISTORTION;
53
54 typedef struct best_mode_struct {
55 int yrd;
56 int rd;
57 int intra_rd;
58 MB_MODE_INFO mbmode;
59 union b_mode_info bmodes[16];
60 PARTITION_INFO partition;
61 } BEST_MODE;
62
63 static const int auto_speed_thresh[17] = { 1000, 200, 150, 130, 150, 125,
64 120, 115, 115, 115, 115, 115,
65 115, 115, 115, 115, 105 };
66
67 const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES] = {
68 ZEROMV, DC_PRED,
69
70 NEARESTMV, NEARMV,
71
72 ZEROMV, NEARESTMV,
73
74 ZEROMV, NEARESTMV,
75
76 NEARMV, NEARMV,
77
78 V_PRED, H_PRED, TM_PRED,
79
80 NEWMV, NEWMV, NEWMV,
81
82 SPLITMV, SPLITMV, SPLITMV,
83
84 B_PRED,
85 };
86
87 /* This table determines the search order in reference frame priority order,
88 * which may not necessarily match INTRA,LAST,GOLDEN,ARF
89 */
90 const int vp8_ref_frame_order[MAX_MODES] = {
91 1, 0,
92
93 1, 1,
94
95 2, 2,
96
97 3, 3,
98
99 2, 3,
100
101 0, 0, 0,
102
103 1, 2, 3,
104
105 1, 2, 3,
106
107 0,
108 };
109
fill_token_costs(int c[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS],const vp8_prob p[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES])110 static void fill_token_costs(
111 int c[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS],
112 const vp8_prob p[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS]
113 [ENTROPY_NODES]) {
114 int i, j, k;
115
116 for (i = 0; i < BLOCK_TYPES; ++i) {
117 for (j = 0; j < COEF_BANDS; ++j) {
118 for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
119 /* check for pt=0 and band > 1 if block type 0
120 * and 0 if blocktype 1
121 */
122 if (k == 0 && j > (i == 0)) {
123 vp8_cost_tokens2(c[i][j][k], p[i][j][k], vp8_coef_tree, 2);
124 } else {
125 vp8_cost_tokens(c[i][j][k], p[i][j][k], vp8_coef_tree);
126 }
127 }
128 }
129 }
130 }
131
132 static const int rd_iifactor[32] = { 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0,
133 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
134 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
135
136 /* values are now correlated to quantizer */
137 static const int sad_per_bit16lut[QINDEX_RANGE] = {
138 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
139 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
140 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6,
141 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
142 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9,
143 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11,
144 11, 11, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14
145 };
146 static const int sad_per_bit4lut[QINDEX_RANGE] = {
147 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
148 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6,
149 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
150 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
151 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12,
152 12, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16,
153 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 20, 20, 20,
154 };
155
vp8cx_initialize_me_consts(VP8_COMP * cpi,int QIndex)156 void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex) {
157 cpi->mb.sadperbit16 = sad_per_bit16lut[QIndex];
158 cpi->mb.sadperbit4 = sad_per_bit4lut[QIndex];
159 }
160
vp8_initialize_rd_consts(VP8_COMP * cpi,MACROBLOCK * x,int Qvalue)161 void vp8_initialize_rd_consts(VP8_COMP *cpi, MACROBLOCK *x, int Qvalue) {
162 int q;
163 int i;
164 double capped_q = (Qvalue < 160) ? (double)Qvalue : 160.0;
165 double rdconst = 2.80;
166
167 vpx_clear_system_state();
168
169 /* Further tests required to see if optimum is different
170 * for key frames, golden frames and arf frames.
171 */
172 cpi->RDMULT = (int)(rdconst * (capped_q * capped_q));
173
174 /* Extend rate multiplier along side quantizer zbin increases */
175 if (cpi->mb.zbin_over_quant > 0) {
176 double oq_factor;
177 double modq;
178
179 /* Experimental code using the same basic equation as used for Q above
180 * The units of cpi->mb.zbin_over_quant are 1/128 of Q bin size
181 */
182 oq_factor = 1.0 + ((double)0.0015625 * cpi->mb.zbin_over_quant);
183 modq = (int)((double)capped_q * oq_factor);
184 cpi->RDMULT = (int)(rdconst * (modq * modq));
185 }
186
187 if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {
188 if (cpi->twopass.next_iiratio > 31) {
189 cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
190 } else {
191 cpi->RDMULT +=
192 (cpi->RDMULT * rd_iifactor[cpi->twopass.next_iiratio]) >> 4;
193 }
194 }
195
196 cpi->mb.errorperbit = (cpi->RDMULT / 110);
197 cpi->mb.errorperbit += (cpi->mb.errorperbit == 0);
198
199 vp8_set_speed_features(cpi);
200
201 for (i = 0; i < MAX_MODES; ++i) {
202 x->mode_test_hit_counts[i] = 0;
203 }
204
205 q = (int)pow(Qvalue, 1.25);
206
207 if (q < 8) q = 8;
208
209 if (cpi->RDMULT > 1000) {
210 cpi->RDDIV = 1;
211 cpi->RDMULT /= 100;
212
213 for (i = 0; i < MAX_MODES; ++i) {
214 if (cpi->sf.thresh_mult[i] < INT_MAX) {
215 x->rd_threshes[i] = cpi->sf.thresh_mult[i] * q / 100;
216 } else {
217 x->rd_threshes[i] = INT_MAX;
218 }
219
220 cpi->rd_baseline_thresh[i] = x->rd_threshes[i];
221 }
222 } else {
223 cpi->RDDIV = 100;
224
225 for (i = 0; i < MAX_MODES; ++i) {
226 if (cpi->sf.thresh_mult[i] < (INT_MAX / q)) {
227 x->rd_threshes[i] = cpi->sf.thresh_mult[i] * q;
228 } else {
229 x->rd_threshes[i] = INT_MAX;
230 }
231
232 cpi->rd_baseline_thresh[i] = x->rd_threshes[i];
233 }
234 }
235
236 {
237 /* build token cost array for the type of frame we have now */
238 FRAME_CONTEXT *l = &cpi->lfc_n;
239
240 if (cpi->common.refresh_alt_ref_frame) {
241 l = &cpi->lfc_a;
242 } else if (cpi->common.refresh_golden_frame) {
243 l = &cpi->lfc_g;
244 }
245
246 fill_token_costs(cpi->mb.token_costs,
247 (const vp8_prob(*)[8][3][11])l->coef_probs);
248 /*
249 fill_token_costs(
250 cpi->mb.token_costs,
251 (const vp8_prob( *)[8][3][11]) cpi->common.fc.coef_probs);
252 */
253
254 /* TODO make these mode costs depend on last,alt or gold too. (jbb) */
255 vp8_init_mode_costs(cpi);
256 }
257 }
258
vp8_auto_select_speed(VP8_COMP * cpi)259 void vp8_auto_select_speed(VP8_COMP *cpi) {
260 int milliseconds_for_compress = (int)(1000000 / cpi->framerate);
261
262 milliseconds_for_compress =
263 milliseconds_for_compress * (16 - cpi->oxcf.cpu_used) / 16;
264
265 #if 0
266
267 if (0)
268 {
269 FILE *f;
270
271 f = fopen("speed.stt", "a");
272 fprintf(f, " %8ld %10ld %10ld %10ld\n",
273 cpi->common.current_video_frame, cpi->Speed, milliseconds_for_compress, cpi->avg_pick_mode_time);
274 fclose(f);
275 }
276
277 #endif
278
279 if (cpi->avg_pick_mode_time < milliseconds_for_compress &&
280 (cpi->avg_encode_time - cpi->avg_pick_mode_time) <
281 milliseconds_for_compress) {
282 if (cpi->avg_pick_mode_time == 0) {
283 cpi->Speed = 4;
284 } else {
285 if (milliseconds_for_compress * 100 < cpi->avg_encode_time * 95) {
286 cpi->Speed += 2;
287 cpi->avg_pick_mode_time = 0;
288 cpi->avg_encode_time = 0;
289
290 if (cpi->Speed > 16) {
291 cpi->Speed = 16;
292 }
293 }
294
295 if (milliseconds_for_compress * 100 >
296 cpi->avg_encode_time * auto_speed_thresh[cpi->Speed]) {
297 cpi->Speed -= 1;
298 cpi->avg_pick_mode_time = 0;
299 cpi->avg_encode_time = 0;
300
301 /* In real-time mode, cpi->speed is in [4, 16]. */
302 if (cpi->Speed < 4) {
303 cpi->Speed = 4;
304 }
305 }
306 }
307 } else {
308 cpi->Speed += 4;
309
310 if (cpi->Speed > 16) cpi->Speed = 16;
311
312 cpi->avg_pick_mode_time = 0;
313 cpi->avg_encode_time = 0;
314 }
315 }
316
vp8_block_error_c(short * coeff,short * dqcoeff)317 int vp8_block_error_c(short *coeff, short *dqcoeff) {
318 int i;
319 int error = 0;
320
321 for (i = 0; i < 16; ++i) {
322 int this_diff = coeff[i] - dqcoeff[i];
323 error += this_diff * this_diff;
324 }
325
326 return error;
327 }
328
vp8_mbblock_error_c(MACROBLOCK * mb,int dc)329 int vp8_mbblock_error_c(MACROBLOCK *mb, int dc) {
330 BLOCK *be;
331 BLOCKD *bd;
332 int i, j;
333 int berror, error = 0;
334
335 for (i = 0; i < 16; ++i) {
336 be = &mb->block[i];
337 bd = &mb->e_mbd.block[i];
338
339 berror = 0;
340
341 for (j = dc; j < 16; ++j) {
342 int this_diff = be->coeff[j] - bd->dqcoeff[j];
343 berror += this_diff * this_diff;
344 }
345
346 error += berror;
347 }
348
349 return error;
350 }
351
vp8_mbuverror_c(MACROBLOCK * mb)352 int vp8_mbuverror_c(MACROBLOCK *mb) {
353 BLOCK *be;
354 BLOCKD *bd;
355
356 int i;
357 int error = 0;
358
359 for (i = 16; i < 24; ++i) {
360 be = &mb->block[i];
361 bd = &mb->e_mbd.block[i];
362
363 error += vp8_block_error_c(be->coeff, bd->dqcoeff);
364 }
365
366 return error;
367 }
368
VP8_UVSSE(MACROBLOCK * x)369 int VP8_UVSSE(MACROBLOCK *x) {
370 unsigned char *uptr, *vptr;
371 unsigned char *upred_ptr = (*(x->block[16].base_src) + x->block[16].src);
372 unsigned char *vpred_ptr = (*(x->block[20].base_src) + x->block[20].src);
373 int uv_stride = x->block[16].src_stride;
374
375 unsigned int sse1 = 0;
376 unsigned int sse2 = 0;
377 int mv_row = x->e_mbd.mode_info_context->mbmi.mv.as_mv.row;
378 int mv_col = x->e_mbd.mode_info_context->mbmi.mv.as_mv.col;
379 int offset;
380 int pre_stride = x->e_mbd.pre.uv_stride;
381
382 if (mv_row < 0) {
383 mv_row -= 1;
384 } else {
385 mv_row += 1;
386 }
387
388 if (mv_col < 0) {
389 mv_col -= 1;
390 } else {
391 mv_col += 1;
392 }
393
394 mv_row /= 2;
395 mv_col /= 2;
396
397 offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
398 uptr = x->e_mbd.pre.u_buffer + offset;
399 vptr = x->e_mbd.pre.v_buffer + offset;
400
401 if ((mv_row | mv_col) & 7) {
402 vpx_sub_pixel_variance8x8(uptr, pre_stride, mv_col & 7, mv_row & 7,
403 upred_ptr, uv_stride, &sse2);
404 vpx_sub_pixel_variance8x8(vptr, pre_stride, mv_col & 7, mv_row & 7,
405 vpred_ptr, uv_stride, &sse1);
406 sse2 += sse1;
407 } else {
408 vpx_variance8x8(uptr, pre_stride, upred_ptr, uv_stride, &sse2);
409 vpx_variance8x8(vptr, pre_stride, vpred_ptr, uv_stride, &sse1);
410 sse2 += sse1;
411 }
412 return sse2;
413 }
414
cost_coeffs(MACROBLOCK * mb,BLOCKD * b,int type,ENTROPY_CONTEXT * a,ENTROPY_CONTEXT * l)415 static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type, ENTROPY_CONTEXT *a,
416 ENTROPY_CONTEXT *l) {
417 int c = !type; /* start at coef 0, unless Y with Y2 */
418 int eob = (int)(*b->eob);
419 int pt; /* surrounding block/prev coef predictor */
420 int cost = 0;
421 short *qcoeff_ptr = b->qcoeff;
422
423 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
424
425 assert(eob <= 16);
426 for (; c < eob; ++c) {
427 const int v = qcoeff_ptr[vp8_default_zig_zag1d[c]];
428 const int t = vp8_dct_value_tokens_ptr[v].Token;
429 cost += mb->token_costs[type][vp8_coef_bands[c]][pt][t];
430 cost += vp8_dct_value_cost_ptr[v];
431 pt = vp8_prev_token_class[t];
432 }
433
434 if (c < 16) {
435 cost += mb->token_costs[type][vp8_coef_bands[c]][pt][DCT_EOB_TOKEN];
436 }
437
438 pt = (c != !type); /* is eob first coefficient; */
439 *a = *l = pt;
440
441 return cost;
442 }
443
vp8_rdcost_mby(MACROBLOCK * mb)444 static int vp8_rdcost_mby(MACROBLOCK *mb) {
445 int cost = 0;
446 int b;
447 MACROBLOCKD *x = &mb->e_mbd;
448 ENTROPY_CONTEXT_PLANES t_above, t_left;
449 ENTROPY_CONTEXT *ta;
450 ENTROPY_CONTEXT *tl;
451
452 memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
453 memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
454
455 ta = (ENTROPY_CONTEXT *)&t_above;
456 tl = (ENTROPY_CONTEXT *)&t_left;
457
458 for (b = 0; b < 16; ++b) {
459 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_NO_DC,
460 ta + vp8_block2above[b], tl + vp8_block2left[b]);
461 }
462
463 cost += cost_coeffs(mb, x->block + 24, PLANE_TYPE_Y2,
464 ta + vp8_block2above[24], tl + vp8_block2left[24]);
465
466 return cost;
467 }
468
macro_block_yrd(MACROBLOCK * mb,int * Rate,int * Distortion)469 static void macro_block_yrd(MACROBLOCK *mb, int *Rate, int *Distortion) {
470 int b;
471 MACROBLOCKD *const x = &mb->e_mbd;
472 BLOCK *const mb_y2 = mb->block + 24;
473 BLOCKD *const x_y2 = x->block + 24;
474 short *Y2DCPtr = mb_y2->src_diff;
475 BLOCK *beptr;
476 int d;
477
478 vp8_subtract_mby(mb->src_diff, *(mb->block[0].base_src),
479 mb->block[0].src_stride, mb->e_mbd.predictor, 16);
480
481 /* Fdct and building the 2nd order block */
482 for (beptr = mb->block; beptr < mb->block + 16; beptr += 2) {
483 mb->short_fdct8x4(beptr->src_diff, beptr->coeff, 32);
484 *Y2DCPtr++ = beptr->coeff[0];
485 *Y2DCPtr++ = beptr->coeff[16];
486 }
487
488 /* 2nd order fdct */
489 mb->short_walsh4x4(mb_y2->src_diff, mb_y2->coeff, 8);
490
491 /* Quantization */
492 for (b = 0; b < 16; ++b) {
493 mb->quantize_b(&mb->block[b], &mb->e_mbd.block[b]);
494 }
495
496 /* DC predication and Quantization of 2nd Order block */
497 mb->quantize_b(mb_y2, x_y2);
498
499 /* Distortion */
500 d = vp8_mbblock_error(mb, 1) << 2;
501 d += vp8_block_error(mb_y2->coeff, x_y2->dqcoeff);
502
503 *Distortion = (d >> 4);
504
505 /* rate */
506 *Rate = vp8_rdcost_mby(mb);
507 }
508
copy_predictor(unsigned char * dst,const unsigned char * predictor)509 static void copy_predictor(unsigned char *dst, const unsigned char *predictor) {
510 const unsigned int *p = (const unsigned int *)predictor;
511 unsigned int *d = (unsigned int *)dst;
512 d[0] = p[0];
513 d[4] = p[4];
514 d[8] = p[8];
515 d[12] = p[12];
516 }
rd_pick_intra4x4block(MACROBLOCK * x,BLOCK * be,BLOCKD * b,B_PREDICTION_MODE * best_mode,const int * bmode_costs,ENTROPY_CONTEXT * a,ENTROPY_CONTEXT * l,int * bestrate,int * bestratey,int * bestdistortion)517 static int rd_pick_intra4x4block(MACROBLOCK *x, BLOCK *be, BLOCKD *b,
518 B_PREDICTION_MODE *best_mode,
519 const int *bmode_costs, ENTROPY_CONTEXT *a,
520 ENTROPY_CONTEXT *l,
521
522 int *bestrate, int *bestratey,
523 int *bestdistortion) {
524 B_PREDICTION_MODE mode;
525 int best_rd = INT_MAX;
526 int rate = 0;
527 int distortion;
528
529 ENTROPY_CONTEXT ta = *a, tempa = *a;
530 ENTROPY_CONTEXT tl = *l, templ = *l;
531 /*
532 * The predictor buffer is a 2d buffer with a stride of 16. Create
533 * a temp buffer that meets the stride requirements, but we are only
534 * interested in the left 4x4 block
535 * */
536 DECLARE_ALIGNED(16, unsigned char, best_predictor[16 * 4]);
537 DECLARE_ALIGNED(16, short, best_dqcoeff[16]);
538 int dst_stride = x->e_mbd.dst.y_stride;
539 unsigned char *dst = x->e_mbd.dst.y_buffer + b->offset;
540
541 unsigned char *Above = dst - dst_stride;
542 unsigned char *yleft = dst - 1;
543 unsigned char top_left = Above[-1];
544
545 for (mode = B_DC_PRED; mode <= B_HU_PRED; ++mode) {
546 int this_rd;
547 int ratey;
548
549 rate = bmode_costs[mode];
550
551 vp8_intra4x4_predict(Above, yleft, dst_stride, mode, b->predictor, 16,
552 top_left);
553 vp8_subtract_b(be, b, 16);
554 x->short_fdct4x4(be->src_diff, be->coeff, 32);
555 x->quantize_b(be, b);
556
557 tempa = ta;
558 templ = tl;
559
560 ratey = cost_coeffs(x, b, PLANE_TYPE_Y_WITH_DC, &tempa, &templ);
561 rate += ratey;
562 distortion = vp8_block_error(be->coeff, b->dqcoeff) >> 2;
563
564 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
565
566 if (this_rd < best_rd) {
567 *bestrate = rate;
568 *bestratey = ratey;
569 *bestdistortion = distortion;
570 best_rd = this_rd;
571 *best_mode = mode;
572 *a = tempa;
573 *l = templ;
574 copy_predictor(best_predictor, b->predictor);
575 memcpy(best_dqcoeff, b->dqcoeff, 32);
576 }
577 }
578 b->bmi.as_mode = *best_mode;
579
580 vp8_short_idct4x4llm(best_dqcoeff, best_predictor, 16, dst, dst_stride);
581
582 return best_rd;
583 }
584
rd_pick_intra4x4mby_modes(MACROBLOCK * mb,int * Rate,int * rate_y,int * Distortion,int best_rd)585 static int rd_pick_intra4x4mby_modes(MACROBLOCK *mb, int *Rate, int *rate_y,
586 int *Distortion, int best_rd) {
587 MACROBLOCKD *const xd = &mb->e_mbd;
588 int i;
589 int cost = mb->mbmode_cost[xd->frame_type][B_PRED];
590 int distortion = 0;
591 int tot_rate_y = 0;
592 int64_t total_rd = 0;
593 ENTROPY_CONTEXT_PLANES t_above, t_left;
594 ENTROPY_CONTEXT *ta;
595 ENTROPY_CONTEXT *tl;
596 const int *bmode_costs;
597
598 memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
599 memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
600
601 ta = (ENTROPY_CONTEXT *)&t_above;
602 tl = (ENTROPY_CONTEXT *)&t_left;
603
604 intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->dst.y_stride + 16);
605
606 bmode_costs = mb->inter_bmode_costs;
607
608 for (i = 0; i < 16; ++i) {
609 MODE_INFO *const mic = xd->mode_info_context;
610 const int mis = xd->mode_info_stride;
611 B_PREDICTION_MODE best_mode = B_MODE_COUNT;
612 int r = 0, ry = 0, d = 0;
613
614 if (mb->e_mbd.frame_type == KEY_FRAME) {
615 const B_PREDICTION_MODE A = above_block_mode(mic, i, mis);
616 const B_PREDICTION_MODE L = left_block_mode(mic, i);
617
618 bmode_costs = mb->bmode_costs[A][L];
619 }
620
621 total_rd += rd_pick_intra4x4block(
622 mb, mb->block + i, xd->block + i, &best_mode, bmode_costs,
623 ta + vp8_block2above[i], tl + vp8_block2left[i], &r, &ry, &d);
624
625 cost += r;
626 distortion += d;
627 tot_rate_y += ry;
628
629 assert(best_mode != B_MODE_COUNT);
630 mic->bmi[i].as_mode = best_mode;
631
632 if (total_rd >= (int64_t)best_rd) break;
633 }
634
635 if (total_rd >= (int64_t)best_rd) return INT_MAX;
636
637 *Rate = cost;
638 *rate_y = tot_rate_y;
639 *Distortion = distortion;
640
641 return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
642 }
643
rd_pick_intra16x16mby_mode(MACROBLOCK * x,int * Rate,int * rate_y,int * Distortion)644 static int rd_pick_intra16x16mby_mode(MACROBLOCK *x, int *Rate, int *rate_y,
645 int *Distortion) {
646 MB_PREDICTION_MODE mode;
647 MB_PREDICTION_MODE mode_selected = MB_MODE_COUNT;
648 int rate, ratey;
649 int distortion;
650 int best_rd = INT_MAX;
651 int this_rd;
652 MACROBLOCKD *xd = &x->e_mbd;
653
654 /* Y Search for 16x16 intra prediction mode */
655 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
656 xd->mode_info_context->mbmi.mode = mode;
657
658 vp8_build_intra_predictors_mby_s(xd, xd->dst.y_buffer - xd->dst.y_stride,
659 xd->dst.y_buffer - 1, xd->dst.y_stride,
660 xd->predictor, 16);
661
662 macro_block_yrd(x, &ratey, &distortion);
663 rate = ratey +
664 x->mbmode_cost[xd->frame_type][xd->mode_info_context->mbmi.mode];
665
666 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
667
668 if (this_rd < best_rd) {
669 mode_selected = mode;
670 best_rd = this_rd;
671 *Rate = rate;
672 *rate_y = ratey;
673 *Distortion = distortion;
674 }
675 }
676
677 assert(mode_selected != MB_MODE_COUNT);
678 xd->mode_info_context->mbmi.mode = mode_selected;
679 return best_rd;
680 }
681
rd_cost_mbuv(MACROBLOCK * mb)682 static int rd_cost_mbuv(MACROBLOCK *mb) {
683 int b;
684 int cost = 0;
685 MACROBLOCKD *x = &mb->e_mbd;
686 ENTROPY_CONTEXT_PLANES t_above, t_left;
687 ENTROPY_CONTEXT *ta;
688 ENTROPY_CONTEXT *tl;
689
690 memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
691 memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
692
693 ta = (ENTROPY_CONTEXT *)&t_above;
694 tl = (ENTROPY_CONTEXT *)&t_left;
695
696 for (b = 16; b < 24; ++b) {
697 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_UV,
698 ta + vp8_block2above[b], tl + vp8_block2left[b]);
699 }
700
701 return cost;
702 }
703
rd_inter16x16_uv(VP8_COMP * cpi,MACROBLOCK * x,int * rate,int * distortion,int fullpixel)704 static int rd_inter16x16_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate,
705 int *distortion, int fullpixel) {
706 (void)cpi;
707 (void)fullpixel;
708
709 vp8_build_inter16x16_predictors_mbuv(&x->e_mbd);
710 vp8_subtract_mbuv(x->src_diff, x->src.u_buffer, x->src.v_buffer,
711 x->src.uv_stride, &x->e_mbd.predictor[256],
712 &x->e_mbd.predictor[320], 8);
713
714 vp8_transform_mbuv(x);
715 vp8_quantize_mbuv(x);
716
717 *rate = rd_cost_mbuv(x);
718 *distortion = vp8_mbuverror(x) / 4;
719
720 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
721 }
722
rd_inter4x4_uv(VP8_COMP * cpi,MACROBLOCK * x,int * rate,int * distortion,int fullpixel)723 static int rd_inter4x4_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate,
724 int *distortion, int fullpixel) {
725 (void)cpi;
726 (void)fullpixel;
727
728 vp8_build_inter4x4_predictors_mbuv(&x->e_mbd);
729 vp8_subtract_mbuv(x->src_diff, x->src.u_buffer, x->src.v_buffer,
730 x->src.uv_stride, &x->e_mbd.predictor[256],
731 &x->e_mbd.predictor[320], 8);
732
733 vp8_transform_mbuv(x);
734 vp8_quantize_mbuv(x);
735
736 *rate = rd_cost_mbuv(x);
737 *distortion = vp8_mbuverror(x) / 4;
738
739 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
740 }
741
rd_pick_intra_mbuv_mode(MACROBLOCK * x,int * rate,int * rate_tokenonly,int * distortion)742 static void rd_pick_intra_mbuv_mode(MACROBLOCK *x, int *rate,
743 int *rate_tokenonly, int *distortion) {
744 MB_PREDICTION_MODE mode;
745 MB_PREDICTION_MODE mode_selected = MB_MODE_COUNT;
746 int best_rd = INT_MAX;
747 int d = 0, r = 0;
748 int rate_to;
749 MACROBLOCKD *xd = &x->e_mbd;
750
751 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
752 int this_rate;
753 int this_distortion;
754 int this_rd;
755
756 xd->mode_info_context->mbmi.uv_mode = mode;
757
758 vp8_build_intra_predictors_mbuv_s(
759 xd, xd->dst.u_buffer - xd->dst.uv_stride,
760 xd->dst.v_buffer - xd->dst.uv_stride, xd->dst.u_buffer - 1,
761 xd->dst.v_buffer - 1, xd->dst.uv_stride, &xd->predictor[256],
762 &xd->predictor[320], 8);
763
764 vp8_subtract_mbuv(x->src_diff, x->src.u_buffer, x->src.v_buffer,
765 x->src.uv_stride, &xd->predictor[256],
766 &xd->predictor[320], 8);
767 vp8_transform_mbuv(x);
768 vp8_quantize_mbuv(x);
769
770 rate_to = rd_cost_mbuv(x);
771 this_rate = rate_to +
772 x->intra_uv_mode_cost[xd->frame_type]
773 [xd->mode_info_context->mbmi.uv_mode];
774
775 this_distortion = vp8_mbuverror(x) / 4;
776
777 this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
778
779 if (this_rd < best_rd) {
780 best_rd = this_rd;
781 d = this_distortion;
782 r = this_rate;
783 *rate_tokenonly = rate_to;
784 mode_selected = mode;
785 }
786 }
787
788 *rate = r;
789 *distortion = d;
790
791 assert(mode_selected != MB_MODE_COUNT);
792 xd->mode_info_context->mbmi.uv_mode = mode_selected;
793 }
794
vp8_cost_mv_ref(MB_PREDICTION_MODE m,const int near_mv_ref_ct[4])795 int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]) {
796 vp8_prob p[VP8_MVREFS - 1];
797 assert(NEARESTMV <= m && m <= SPLITMV);
798 vp8_mv_ref_probs(p, near_mv_ref_ct);
799 return vp8_cost_token(vp8_mv_ref_tree, p,
800 vp8_mv_ref_encoding_array + (m - NEARESTMV));
801 }
802
vp8_set_mbmode_and_mvs(MACROBLOCK * x,MB_PREDICTION_MODE mb,int_mv * mv)803 void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv) {
804 x->e_mbd.mode_info_context->mbmi.mode = mb;
805 x->e_mbd.mode_info_context->mbmi.mv.as_int = mv->as_int;
806 }
807
labels2mode(MACROBLOCK * x,int const * labelings,int which_label,B_PREDICTION_MODE this_mode,int_mv * this_mv,int_mv * best_ref_mv,int * mvcost[2])808 static int labels2mode(MACROBLOCK *x, int const *labelings, int which_label,
809 B_PREDICTION_MODE this_mode, int_mv *this_mv,
810 int_mv *best_ref_mv, int *mvcost[2]) {
811 MACROBLOCKD *const xd = &x->e_mbd;
812 MODE_INFO *const mic = xd->mode_info_context;
813 const int mis = xd->mode_info_stride;
814
815 int cost = 0;
816 int thismvcost = 0;
817
818 /* We have to be careful retrieving previously-encoded motion vectors.
819 Ones from this macroblock have to be pulled from the BLOCKD array
820 as they have not yet made it to the bmi array in our MB_MODE_INFO. */
821
822 int i = 0;
823
824 do {
825 BLOCKD *const d = xd->block + i;
826 const int row = i >> 2, col = i & 3;
827
828 B_PREDICTION_MODE m;
829
830 if (labelings[i] != which_label) continue;
831
832 if (col && labelings[i] == labelings[i - 1]) {
833 m = LEFT4X4;
834 } else if (row && labelings[i] == labelings[i - 4]) {
835 m = ABOVE4X4;
836 } else {
837 /* the only time we should do costing for new motion vector
838 * or mode is when we are on a new label (jbb May 08, 2007)
839 */
840 switch (m = this_mode) {
841 case NEW4X4:
842 thismvcost = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
843 break;
844 case LEFT4X4:
845 this_mv->as_int = col ? d[-1].bmi.mv.as_int : left_block_mv(mic, i);
846 break;
847 case ABOVE4X4:
848 this_mv->as_int =
849 row ? d[-4].bmi.mv.as_int : above_block_mv(mic, i, mis);
850 break;
851 case ZERO4X4: this_mv->as_int = 0; break;
852 default: break;
853 }
854
855 if (m == ABOVE4X4) /* replace above with left if same */
856 {
857 int_mv left_mv;
858
859 left_mv.as_int = col ? d[-1].bmi.mv.as_int : left_block_mv(mic, i);
860
861 if (left_mv.as_int == this_mv->as_int) m = LEFT4X4;
862 }
863
864 cost = x->inter_bmode_costs[m];
865 }
866
867 d->bmi.mv.as_int = this_mv->as_int;
868
869 x->partition_info->bmi[i].mode = m;
870 x->partition_info->bmi[i].mv.as_int = this_mv->as_int;
871
872 } while (++i < 16);
873
874 cost += thismvcost;
875 return cost;
876 }
877
rdcost_mbsegment_y(MACROBLOCK * mb,const int * labels,int which_label,ENTROPY_CONTEXT * ta,ENTROPY_CONTEXT * tl)878 static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels,
879 int which_label, ENTROPY_CONTEXT *ta,
880 ENTROPY_CONTEXT *tl) {
881 int cost = 0;
882 int b;
883 MACROBLOCKD *x = &mb->e_mbd;
884
885 for (b = 0; b < 16; ++b) {
886 if (labels[b] == which_label) {
887 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_WITH_DC,
888 ta + vp8_block2above[b], tl + vp8_block2left[b]);
889 }
890 }
891
892 return cost;
893 }
vp8_encode_inter_mb_segment(MACROBLOCK * x,int const * labels,int which_label)894 static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x,
895 int const *labels,
896 int which_label) {
897 int i;
898 unsigned int distortion = 0;
899 int pre_stride = x->e_mbd.pre.y_stride;
900 unsigned char *base_pre = x->e_mbd.pre.y_buffer;
901
902 for (i = 0; i < 16; ++i) {
903 if (labels[i] == which_label) {
904 BLOCKD *bd = &x->e_mbd.block[i];
905 BLOCK *be = &x->block[i];
906
907 vp8_build_inter_predictors_b(bd, 16, base_pre, pre_stride,
908 x->e_mbd.subpixel_predict);
909 vp8_subtract_b(be, bd, 16);
910 x->short_fdct4x4(be->src_diff, be->coeff, 32);
911 x->quantize_b(be, bd);
912
913 distortion += vp8_block_error(be->coeff, bd->dqcoeff);
914 }
915 }
916
917 return distortion;
918 }
919
920 static const unsigned int segmentation_to_sseshift[4] = { 3, 3, 2, 0 };
921
922 typedef struct {
923 int_mv *ref_mv;
924 int_mv mvp;
925
926 int segment_rd;
927 int segment_num;
928 int r;
929 int d;
930 int segment_yrate;
931 B_PREDICTION_MODE modes[16];
932 int_mv mvs[16];
933 unsigned char eobs[16];
934
935 int mvthresh;
936 int *mdcounts;
937
938 int_mv sv_mvp[4]; /* save 4 mvp from 8x8 */
939 int sv_istep[2]; /* save 2 initial step_param for 16x8/8x16 */
940
941 } BEST_SEG_INFO;
942
rd_check_segment(VP8_COMP * cpi,MACROBLOCK * x,BEST_SEG_INFO * bsi,unsigned int segmentation)943 static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x, BEST_SEG_INFO *bsi,
944 unsigned int segmentation) {
945 int i;
946 int const *labels;
947 int br = 0;
948 int bd = 0;
949 B_PREDICTION_MODE this_mode;
950
951 int label_count;
952 int this_segment_rd = 0;
953 int label_mv_thresh;
954 int rate = 0;
955 int sbr = 0;
956 int sbd = 0;
957 int segmentyrate = 0;
958
959 vp8_variance_fn_ptr_t *v_fn_ptr;
960
961 ENTROPY_CONTEXT_PLANES t_above, t_left;
962 ENTROPY_CONTEXT *ta;
963 ENTROPY_CONTEXT *tl;
964 ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
965 ENTROPY_CONTEXT *ta_b;
966 ENTROPY_CONTEXT *tl_b;
967
968 memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
969 memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
970
971 ta = (ENTROPY_CONTEXT *)&t_above;
972 tl = (ENTROPY_CONTEXT *)&t_left;
973 ta_b = (ENTROPY_CONTEXT *)&t_above_b;
974 tl_b = (ENTROPY_CONTEXT *)&t_left_b;
975
976 br = 0;
977 bd = 0;
978
979 v_fn_ptr = &cpi->fn_ptr[segmentation];
980 labels = vp8_mbsplits[segmentation];
981 label_count = vp8_mbsplit_count[segmentation];
982
983 /* 64 makes this threshold really big effectively making it so that we
984 * very rarely check mvs on segments. setting this to 1 would make mv
985 * thresh roughly equal to what it is for macroblocks
986 */
987 label_mv_thresh = 1 * bsi->mvthresh / label_count;
988
989 /* Segmentation method overheads */
990 rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs,
991 vp8_mbsplit_encodings + segmentation);
992 rate += vp8_cost_mv_ref(SPLITMV, bsi->mdcounts);
993 this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
994 br += rate;
995
996 for (i = 0; i < label_count; ++i) {
997 int_mv mode_mv[B_MODE_COUNT];
998 int best_label_rd = INT_MAX;
999 B_PREDICTION_MODE mode_selected = ZERO4X4;
1000 int bestlabelyrate = 0;
1001
1002 /* search for the best motion vector on this segment */
1003 for (this_mode = LEFT4X4; this_mode <= NEW4X4; ++this_mode) {
1004 int this_rd;
1005 int distortion;
1006 int labelyrate;
1007 ENTROPY_CONTEXT_PLANES t_above_s, t_left_s;
1008 ENTROPY_CONTEXT *ta_s;
1009 ENTROPY_CONTEXT *tl_s;
1010
1011 memcpy(&t_above_s, &t_above, sizeof(ENTROPY_CONTEXT_PLANES));
1012 memcpy(&t_left_s, &t_left, sizeof(ENTROPY_CONTEXT_PLANES));
1013
1014 ta_s = (ENTROPY_CONTEXT *)&t_above_s;
1015 tl_s = (ENTROPY_CONTEXT *)&t_left_s;
1016
1017 if (this_mode == NEW4X4) {
1018 int sseshift;
1019 int num00;
1020 int step_param = 0;
1021 int further_steps;
1022 int n;
1023 int thissme;
1024 int bestsme = INT_MAX;
1025 int_mv temp_mv;
1026 BLOCK *c;
1027 BLOCKD *e;
1028
1029 /* Is the best so far sufficiently good that we cant justify
1030 * doing a new motion search.
1031 */
1032 if (best_label_rd < label_mv_thresh) break;
1033
1034 if (cpi->compressor_speed) {
1035 if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8) {
1036 bsi->mvp.as_int = bsi->sv_mvp[i].as_int;
1037 if (i == 1 && segmentation == BLOCK_16X8) {
1038 bsi->mvp.as_int = bsi->sv_mvp[2].as_int;
1039 }
1040
1041 step_param = bsi->sv_istep[i];
1042 }
1043
1044 /* use previous block's result as next block's MV
1045 * predictor.
1046 */
1047 if (segmentation == BLOCK_4X4 && i > 0) {
1048 bsi->mvp.as_int = x->e_mbd.block[i - 1].bmi.mv.as_int;
1049 if (i == 4 || i == 8 || i == 12) {
1050 bsi->mvp.as_int = x->e_mbd.block[i - 4].bmi.mv.as_int;
1051 }
1052 step_param = 2;
1053 }
1054 }
1055
1056 further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
1057
1058 {
1059 int sadpb = x->sadperbit4;
1060 int_mv mvp_full;
1061
1062 mvp_full.as_mv.row = bsi->mvp.as_mv.row >> 3;
1063 mvp_full.as_mv.col = bsi->mvp.as_mv.col >> 3;
1064
1065 /* find first label */
1066 n = vp8_mbsplit_offset[segmentation][i];
1067
1068 c = &x->block[n];
1069 e = &x->e_mbd.block[n];
1070
1071 {
1072 bestsme = cpi->diamond_search_sad(
1073 x, c, e, &mvp_full, &mode_mv[NEW4X4], step_param, sadpb, &num00,
1074 v_fn_ptr, x->mvcost, bsi->ref_mv);
1075
1076 n = num00;
1077 num00 = 0;
1078
1079 while (n < further_steps) {
1080 n++;
1081
1082 if (num00) {
1083 num00--;
1084 } else {
1085 thissme = cpi->diamond_search_sad(
1086 x, c, e, &mvp_full, &temp_mv, step_param + n, sadpb, &num00,
1087 v_fn_ptr, x->mvcost, bsi->ref_mv);
1088
1089 if (thissme < bestsme) {
1090 bestsme = thissme;
1091 mode_mv[NEW4X4].as_int = temp_mv.as_int;
1092 }
1093 }
1094 }
1095 }
1096
1097 sseshift = segmentation_to_sseshift[segmentation];
1098
1099 /* Should we do a full search (best quality only) */
1100 if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000) {
1101 /* Check if mvp_full is within the range. */
1102 vp8_clamp_mv(&mvp_full, x->mv_col_min, x->mv_col_max, x->mv_row_min,
1103 x->mv_row_max);
1104
1105 thissme = cpi->full_search_sad(x, c, e, &mvp_full, sadpb, 16,
1106 v_fn_ptr, x->mvcost, bsi->ref_mv);
1107
1108 if (thissme < bestsme) {
1109 bestsme = thissme;
1110 mode_mv[NEW4X4].as_int = e->bmi.mv.as_int;
1111 } else {
1112 /* The full search result is actually worse so
1113 * re-instate the previous best vector
1114 */
1115 e->bmi.mv.as_int = mode_mv[NEW4X4].as_int;
1116 }
1117 }
1118 }
1119
1120 if (bestsme < INT_MAX) {
1121 int disto;
1122 unsigned int sse;
1123 cpi->find_fractional_mv_step(x, c, e, &mode_mv[NEW4X4], bsi->ref_mv,
1124 x->errorperbit, v_fn_ptr, x->mvcost,
1125 &disto, &sse);
1126 }
1127 } /* NEW4X4 */
1128
1129 rate = labels2mode(x, labels, i, this_mode, &mode_mv[this_mode],
1130 bsi->ref_mv, x->mvcost);
1131
1132 /* Trap vectors that reach beyond the UMV borders */
1133 if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
1134 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
1135 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
1136 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) {
1137 continue;
1138 }
1139
1140 distortion = vp8_encode_inter_mb_segment(x, labels, i) / 4;
1141
1142 labelyrate = rdcost_mbsegment_y(x, labels, i, ta_s, tl_s);
1143 rate += labelyrate;
1144
1145 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1146
1147 if (this_rd < best_label_rd) {
1148 sbr = rate;
1149 sbd = distortion;
1150 bestlabelyrate = labelyrate;
1151 mode_selected = this_mode;
1152 best_label_rd = this_rd;
1153
1154 memcpy(ta_b, ta_s, sizeof(ENTROPY_CONTEXT_PLANES));
1155 memcpy(tl_b, tl_s, sizeof(ENTROPY_CONTEXT_PLANES));
1156 }
1157 } /*for each 4x4 mode*/
1158
1159 memcpy(ta, ta_b, sizeof(ENTROPY_CONTEXT_PLANES));
1160 memcpy(tl, tl_b, sizeof(ENTROPY_CONTEXT_PLANES));
1161
1162 labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected],
1163 bsi->ref_mv, x->mvcost);
1164
1165 br += sbr;
1166 bd += sbd;
1167 segmentyrate += bestlabelyrate;
1168 this_segment_rd += best_label_rd;
1169
1170 if (this_segment_rd >= bsi->segment_rd) break;
1171
1172 } /* for each label */
1173
1174 if (this_segment_rd < bsi->segment_rd) {
1175 bsi->r = br;
1176 bsi->d = bd;
1177 bsi->segment_yrate = segmentyrate;
1178 bsi->segment_rd = this_segment_rd;
1179 bsi->segment_num = segmentation;
1180
1181 /* store everything needed to come back to this!! */
1182 for (i = 0; i < 16; ++i) {
1183 bsi->mvs[i].as_mv = x->partition_info->bmi[i].mv.as_mv;
1184 bsi->modes[i] = x->partition_info->bmi[i].mode;
1185 bsi->eobs[i] = x->e_mbd.eobs[i];
1186 }
1187 }
1188 }
1189
vp8_cal_step_param(int sr,int * sp)1190 static void vp8_cal_step_param(int sr, int *sp) {
1191 int step = 0;
1192
1193 if (sr > MAX_FIRST_STEP) {
1194 sr = MAX_FIRST_STEP;
1195 } else if (sr < 1) {
1196 sr = 1;
1197 }
1198
1199 while (sr >>= 1) step++;
1200
1201 *sp = MAX_MVSEARCH_STEPS - 1 - step;
1202 }
1203
vp8_rd_pick_best_mbsegmentation(VP8_COMP * cpi,MACROBLOCK * x,int_mv * best_ref_mv,int best_rd,int * mdcounts,int * returntotrate,int * returnyrate,int * returndistortion,int mvthresh)1204 static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
1205 int_mv *best_ref_mv, int best_rd,
1206 int *mdcounts, int *returntotrate,
1207 int *returnyrate,
1208 int *returndistortion,
1209 int mvthresh) {
1210 int i;
1211 BEST_SEG_INFO bsi;
1212
1213 memset(&bsi, 0, sizeof(bsi));
1214
1215 bsi.segment_rd = best_rd;
1216 bsi.ref_mv = best_ref_mv;
1217 bsi.mvp.as_int = best_ref_mv->as_int;
1218 bsi.mvthresh = mvthresh;
1219 bsi.mdcounts = mdcounts;
1220
1221 for (i = 0; i < 16; ++i) {
1222 bsi.modes[i] = ZERO4X4;
1223 }
1224
1225 if (cpi->compressor_speed == 0) {
1226 /* for now, we will keep the original segmentation order
1227 when in best quality mode */
1228 rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1229 rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1230 rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1231 rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1232 } else {
1233 int sr;
1234
1235 rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1236
1237 if (bsi.segment_rd < best_rd) {
1238 int col_min = ((best_ref_mv->as_mv.col + 7) >> 3) - MAX_FULL_PEL_VAL;
1239 int row_min = ((best_ref_mv->as_mv.row + 7) >> 3) - MAX_FULL_PEL_VAL;
1240 int col_max = (best_ref_mv->as_mv.col >> 3) + MAX_FULL_PEL_VAL;
1241 int row_max = (best_ref_mv->as_mv.row >> 3) + MAX_FULL_PEL_VAL;
1242
1243 int tmp_col_min = x->mv_col_min;
1244 int tmp_col_max = x->mv_col_max;
1245 int tmp_row_min = x->mv_row_min;
1246 int tmp_row_max = x->mv_row_max;
1247
1248 /* Get intersection of UMV window and valid MV window to reduce # of
1249 * checks in diamond search. */
1250 if (x->mv_col_min < col_min) x->mv_col_min = col_min;
1251 if (x->mv_col_max > col_max) x->mv_col_max = col_max;
1252 if (x->mv_row_min < row_min) x->mv_row_min = row_min;
1253 if (x->mv_row_max > row_max) x->mv_row_max = row_max;
1254
1255 /* Get 8x8 result */
1256 bsi.sv_mvp[0].as_int = bsi.mvs[0].as_int;
1257 bsi.sv_mvp[1].as_int = bsi.mvs[2].as_int;
1258 bsi.sv_mvp[2].as_int = bsi.mvs[8].as_int;
1259 bsi.sv_mvp[3].as_int = bsi.mvs[10].as_int;
1260
1261 /* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range
1262 * according to the closeness of 2 MV. */
1263 /* block 8X16 */
1264 {
1265 sr =
1266 MAXF((abs(bsi.sv_mvp[0].as_mv.row - bsi.sv_mvp[2].as_mv.row)) >> 3,
1267 (abs(bsi.sv_mvp[0].as_mv.col - bsi.sv_mvp[2].as_mv.col)) >> 3);
1268 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1269
1270 sr =
1271 MAXF((abs(bsi.sv_mvp[1].as_mv.row - bsi.sv_mvp[3].as_mv.row)) >> 3,
1272 (abs(bsi.sv_mvp[1].as_mv.col - bsi.sv_mvp[3].as_mv.col)) >> 3);
1273 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1274
1275 rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1276 }
1277
1278 /* block 16X8 */
1279 {
1280 sr =
1281 MAXF((abs(bsi.sv_mvp[0].as_mv.row - bsi.sv_mvp[1].as_mv.row)) >> 3,
1282 (abs(bsi.sv_mvp[0].as_mv.col - bsi.sv_mvp[1].as_mv.col)) >> 3);
1283 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1284
1285 sr =
1286 MAXF((abs(bsi.sv_mvp[2].as_mv.row - bsi.sv_mvp[3].as_mv.row)) >> 3,
1287 (abs(bsi.sv_mvp[2].as_mv.col - bsi.sv_mvp[3].as_mv.col)) >> 3);
1288 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1289
1290 rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1291 }
1292
1293 /* If 8x8 is better than 16x8/8x16, then do 4x4 search */
1294 /* Not skip 4x4 if speed=0 (good quality) */
1295 if (cpi->sf.no_skip_block4x4_search || bsi.segment_num == BLOCK_8X8)
1296 /* || (sv_segment_rd8x8-bsi.segment_rd) < sv_segment_rd8x8>>5) */
1297 {
1298 bsi.mvp.as_int = bsi.sv_mvp[0].as_int;
1299 rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1300 }
1301
1302 /* restore UMV window */
1303 x->mv_col_min = tmp_col_min;
1304 x->mv_col_max = tmp_col_max;
1305 x->mv_row_min = tmp_row_min;
1306 x->mv_row_max = tmp_row_max;
1307 }
1308 }
1309
1310 /* set it to the best */
1311 for (i = 0; i < 16; ++i) {
1312 BLOCKD *bd = &x->e_mbd.block[i];
1313
1314 bd->bmi.mv.as_int = bsi.mvs[i].as_int;
1315 *bd->eob = bsi.eobs[i];
1316 }
1317
1318 *returntotrate = bsi.r;
1319 *returndistortion = bsi.d;
1320 *returnyrate = bsi.segment_yrate;
1321
1322 /* save partitions */
1323 x->e_mbd.mode_info_context->mbmi.partitioning = bsi.segment_num;
1324 x->partition_info->count = vp8_mbsplit_count[bsi.segment_num];
1325
1326 for (i = 0; i < x->partition_info->count; ++i) {
1327 int j;
1328
1329 j = vp8_mbsplit_offset[bsi.segment_num][i];
1330
1331 x->partition_info->bmi[i].mode = bsi.modes[j];
1332 x->partition_info->bmi[i].mv.as_mv = bsi.mvs[j].as_mv;
1333 }
1334 /*
1335 * used to set x->e_mbd.mode_info_context->mbmi.mv.as_int
1336 */
1337 x->partition_info->bmi[15].mv.as_int = bsi.mvs[15].as_int;
1338
1339 return bsi.segment_rd;
1340 }
1341
1342 /* The improved MV prediction */
vp8_mv_pred(VP8_COMP * cpi,MACROBLOCKD * xd,const MODE_INFO * here,int_mv * mvp,int refframe,int * ref_frame_sign_bias,int * sr,int near_sadidx[])1343 void vp8_mv_pred(VP8_COMP *cpi, MACROBLOCKD *xd, const MODE_INFO *here,
1344 int_mv *mvp, int refframe, int *ref_frame_sign_bias, int *sr,
1345 int near_sadidx[]) {
1346 const MODE_INFO *above = here - xd->mode_info_stride;
1347 const MODE_INFO *left = here - 1;
1348 const MODE_INFO *aboveleft = above - 1;
1349 int_mv near_mvs[8];
1350 int near_ref[8];
1351 int_mv mv;
1352 int vcnt = 0;
1353 int find = 0;
1354 int mb_offset;
1355
1356 int mvx[8];
1357 int mvy[8];
1358 int i;
1359
1360 mv.as_int = 0;
1361
1362 if (here->mbmi.ref_frame != INTRA_FRAME) {
1363 near_mvs[0].as_int = near_mvs[1].as_int = near_mvs[2].as_int =
1364 near_mvs[3].as_int = near_mvs[4].as_int = near_mvs[5].as_int =
1365 near_mvs[6].as_int = near_mvs[7].as_int = 0;
1366 near_ref[0] = near_ref[1] = near_ref[2] = near_ref[3] = near_ref[4] =
1367 near_ref[5] = near_ref[6] = near_ref[7] = 0;
1368
1369 /* read in 3 nearby block's MVs from current frame as prediction
1370 * candidates.
1371 */
1372 if (above->mbmi.ref_frame != INTRA_FRAME) {
1373 near_mvs[vcnt].as_int = above->mbmi.mv.as_int;
1374 mv_bias(ref_frame_sign_bias[above->mbmi.ref_frame], refframe,
1375 &near_mvs[vcnt], ref_frame_sign_bias);
1376 near_ref[vcnt] = above->mbmi.ref_frame;
1377 }
1378 vcnt++;
1379 if (left->mbmi.ref_frame != INTRA_FRAME) {
1380 near_mvs[vcnt].as_int = left->mbmi.mv.as_int;
1381 mv_bias(ref_frame_sign_bias[left->mbmi.ref_frame], refframe,
1382 &near_mvs[vcnt], ref_frame_sign_bias);
1383 near_ref[vcnt] = left->mbmi.ref_frame;
1384 }
1385 vcnt++;
1386 if (aboveleft->mbmi.ref_frame != INTRA_FRAME) {
1387 near_mvs[vcnt].as_int = aboveleft->mbmi.mv.as_int;
1388 mv_bias(ref_frame_sign_bias[aboveleft->mbmi.ref_frame], refframe,
1389 &near_mvs[vcnt], ref_frame_sign_bias);
1390 near_ref[vcnt] = aboveleft->mbmi.ref_frame;
1391 }
1392 vcnt++;
1393
1394 /* read in 5 nearby block's MVs from last frame. */
1395 if (cpi->common.last_frame_type != KEY_FRAME) {
1396 mb_offset = (-xd->mb_to_top_edge / 128 + 1) * (xd->mode_info_stride + 1) +
1397 (-xd->mb_to_left_edge / 128 + 1);
1398
1399 /* current in last frame */
1400 if (cpi->lf_ref_frame[mb_offset] != INTRA_FRAME) {
1401 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset].as_int;
1402 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset], refframe,
1403 &near_mvs[vcnt], ref_frame_sign_bias);
1404 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset];
1405 }
1406 vcnt++;
1407
1408 /* above in last frame */
1409 if (cpi->lf_ref_frame[mb_offset - xd->mode_info_stride - 1] !=
1410 INTRA_FRAME) {
1411 near_mvs[vcnt].as_int =
1412 cpi->lfmv[mb_offset - xd->mode_info_stride - 1].as_int;
1413 mv_bias(
1414 cpi->lf_ref_frame_sign_bias[mb_offset - xd->mode_info_stride - 1],
1415 refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1416 near_ref[vcnt] =
1417 cpi->lf_ref_frame[mb_offset - xd->mode_info_stride - 1];
1418 }
1419 vcnt++;
1420
1421 /* left in last frame */
1422 if (cpi->lf_ref_frame[mb_offset - 1] != INTRA_FRAME) {
1423 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset - 1].as_int;
1424 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset - 1], refframe,
1425 &near_mvs[vcnt], ref_frame_sign_bias);
1426 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset - 1];
1427 }
1428 vcnt++;
1429
1430 /* right in last frame */
1431 if (cpi->lf_ref_frame[mb_offset + 1] != INTRA_FRAME) {
1432 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset + 1].as_int;
1433 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset + 1], refframe,
1434 &near_mvs[vcnt], ref_frame_sign_bias);
1435 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset + 1];
1436 }
1437 vcnt++;
1438
1439 /* below in last frame */
1440 if (cpi->lf_ref_frame[mb_offset + xd->mode_info_stride + 1] !=
1441 INTRA_FRAME) {
1442 near_mvs[vcnt].as_int =
1443 cpi->lfmv[mb_offset + xd->mode_info_stride + 1].as_int;
1444 mv_bias(
1445 cpi->lf_ref_frame_sign_bias[mb_offset + xd->mode_info_stride + 1],
1446 refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1447 near_ref[vcnt] =
1448 cpi->lf_ref_frame[mb_offset + xd->mode_info_stride + 1];
1449 }
1450 vcnt++;
1451 }
1452
1453 for (i = 0; i < vcnt; ++i) {
1454 if (near_ref[near_sadidx[i]] != INTRA_FRAME) {
1455 if (here->mbmi.ref_frame == near_ref[near_sadidx[i]]) {
1456 mv.as_int = near_mvs[near_sadidx[i]].as_int;
1457 find = 1;
1458 if (i < 3) {
1459 *sr = 3;
1460 } else {
1461 *sr = 2;
1462 }
1463 break;
1464 }
1465 }
1466 }
1467
1468 if (!find) {
1469 for (i = 0; i < vcnt; ++i) {
1470 mvx[i] = near_mvs[i].as_mv.row;
1471 mvy[i] = near_mvs[i].as_mv.col;
1472 }
1473
1474 insertsortmv(mvx, vcnt);
1475 insertsortmv(mvy, vcnt);
1476 mv.as_mv.row = mvx[vcnt / 2];
1477 mv.as_mv.col = mvy[vcnt / 2];
1478
1479 /* sr is set to 0 to allow calling function to decide the search
1480 * range.
1481 */
1482 *sr = 0;
1483 }
1484 }
1485
1486 /* Set up return values */
1487 mvp->as_int = mv.as_int;
1488 vp8_clamp_mv2(mvp, xd);
1489 }
1490
vp8_cal_sad(VP8_COMP * cpi,MACROBLOCKD * xd,MACROBLOCK * x,int recon_yoffset,int near_sadidx[])1491 void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x,
1492 int recon_yoffset, int near_sadidx[]) {
1493 /* near_sad indexes:
1494 * 0-cf above, 1-cf left, 2-cf aboveleft,
1495 * 3-lf current, 4-lf above, 5-lf left, 6-lf right, 7-lf below
1496 */
1497 int near_sad[8] = { 0 };
1498 BLOCK *b = &x->block[0];
1499 unsigned char *src_y_ptr = *(b->base_src);
1500
1501 /* calculate sad for current frame 3 nearby MBs. */
1502 if (xd->mb_to_top_edge == 0 && xd->mb_to_left_edge == 0) {
1503 near_sad[0] = near_sad[1] = near_sad[2] = INT_MAX;
1504 } else if (xd->mb_to_top_edge ==
1505 0) { /* only has left MB for sad calculation. */
1506 near_sad[0] = near_sad[2] = INT_MAX;
1507 near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(
1508 src_y_ptr, b->src_stride, xd->dst.y_buffer - 16, xd->dst.y_stride);
1509 } else if (xd->mb_to_left_edge ==
1510 0) { /* only has left MB for sad calculation. */
1511 near_sad[1] = near_sad[2] = INT_MAX;
1512 near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(
1513 src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride * 16,
1514 xd->dst.y_stride);
1515 } else {
1516 near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(
1517 src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride * 16,
1518 xd->dst.y_stride);
1519 near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(
1520 src_y_ptr, b->src_stride, xd->dst.y_buffer - 16, xd->dst.y_stride);
1521 near_sad[2] = cpi->fn_ptr[BLOCK_16X16].sdf(
1522 src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride * 16 - 16,
1523 xd->dst.y_stride);
1524 }
1525
1526 if (cpi->common.last_frame_type != KEY_FRAME) {
1527 /* calculate sad for last frame 5 nearby MBs. */
1528 unsigned char *pre_y_buffer =
1529 cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_buffer + recon_yoffset;
1530 int pre_y_stride = cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_stride;
1531
1532 if (xd->mb_to_top_edge == 0) near_sad[4] = INT_MAX;
1533 if (xd->mb_to_left_edge == 0) near_sad[5] = INT_MAX;
1534 if (xd->mb_to_right_edge == 0) near_sad[6] = INT_MAX;
1535 if (xd->mb_to_bottom_edge == 0) near_sad[7] = INT_MAX;
1536
1537 if (near_sad[4] != INT_MAX) {
1538 near_sad[4] = cpi->fn_ptr[BLOCK_16X16].sdf(
1539 src_y_ptr, b->src_stride, pre_y_buffer - pre_y_stride * 16,
1540 pre_y_stride);
1541 }
1542 if (near_sad[5] != INT_MAX) {
1543 near_sad[5] = cpi->fn_ptr[BLOCK_16X16].sdf(
1544 src_y_ptr, b->src_stride, pre_y_buffer - 16, pre_y_stride);
1545 }
1546 near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride,
1547 pre_y_buffer, pre_y_stride);
1548 if (near_sad[6] != INT_MAX) {
1549 near_sad[6] = cpi->fn_ptr[BLOCK_16X16].sdf(
1550 src_y_ptr, b->src_stride, pre_y_buffer + 16, pre_y_stride);
1551 }
1552 if (near_sad[7] != INT_MAX) {
1553 near_sad[7] = cpi->fn_ptr[BLOCK_16X16].sdf(
1554 src_y_ptr, b->src_stride, pre_y_buffer + pre_y_stride * 16,
1555 pre_y_stride);
1556 }
1557 }
1558
1559 if (cpi->common.last_frame_type != KEY_FRAME) {
1560 insertsortsad(near_sad, near_sadidx, 8);
1561 } else {
1562 insertsortsad(near_sad, near_sadidx, 3);
1563 }
1564 }
1565
rd_update_mvcount(MACROBLOCK * x,int_mv * best_ref_mv)1566 static void rd_update_mvcount(MACROBLOCK *x, int_mv *best_ref_mv) {
1567 if (x->e_mbd.mode_info_context->mbmi.mode == SPLITMV) {
1568 int i;
1569
1570 for (i = 0; i < x->partition_info->count; ++i) {
1571 if (x->partition_info->bmi[i].mode == NEW4X4) {
1572 x->MVcount[0][mv_max + ((x->partition_info->bmi[i].mv.as_mv.row -
1573 best_ref_mv->as_mv.row) >>
1574 1)]++;
1575 x->MVcount[1][mv_max + ((x->partition_info->bmi[i].mv.as_mv.col -
1576 best_ref_mv->as_mv.col) >>
1577 1)]++;
1578 }
1579 }
1580 } else if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV) {
1581 x->MVcount[0][mv_max + ((x->e_mbd.mode_info_context->mbmi.mv.as_mv.row -
1582 best_ref_mv->as_mv.row) >>
1583 1)]++;
1584 x->MVcount[1][mv_max + ((x->e_mbd.mode_info_context->mbmi.mv.as_mv.col -
1585 best_ref_mv->as_mv.col) >>
1586 1)]++;
1587 }
1588 }
1589
evaluate_inter_mode_rd(int mdcounts[4],RATE_DISTORTION * rd,int * disable_skip,VP8_COMP * cpi,MACROBLOCK * x)1590 static int evaluate_inter_mode_rd(int mdcounts[4], RATE_DISTORTION *rd,
1591 int *disable_skip, VP8_COMP *cpi,
1592 MACROBLOCK *x) {
1593 MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode;
1594 BLOCK *b = &x->block[0];
1595 MACROBLOCKD *xd = &x->e_mbd;
1596 int distortion;
1597 vp8_build_inter16x16_predictors_mby(&x->e_mbd, x->e_mbd.predictor, 16);
1598
1599 if (cpi->active_map_enabled && x->active_ptr[0] == 0) {
1600 x->skip = 1;
1601 } else if (x->encode_breakout) {
1602 unsigned int sse;
1603 unsigned int var;
1604 unsigned int threshold =
1605 (xd->block[0].dequant[1] * xd->block[0].dequant[1] >> 4);
1606
1607 if (threshold < x->encode_breakout) threshold = x->encode_breakout;
1608
1609 var = vpx_variance16x16(*(b->base_src), b->src_stride, x->e_mbd.predictor,
1610 16, &sse);
1611
1612 if (sse < threshold) {
1613 unsigned int q2dc = xd->block[24].dequant[0];
1614 /* If theres is no codeable 2nd order dc
1615 or a very small uniform pixel change change */
1616 if ((sse - var<q2dc * q2dc>> 4) || (sse / 2 > var && sse - var < 64)) {
1617 /* Check u and v to make sure skip is ok */
1618 unsigned int sse2 = VP8_UVSSE(x);
1619 if (sse2 * 2 < threshold) {
1620 x->skip = 1;
1621 rd->distortion2 = sse + sse2;
1622 rd->rate2 = 500;
1623
1624 /* for best_yrd calculation */
1625 rd->rate_uv = 0;
1626 rd->distortion_uv = sse2;
1627
1628 *disable_skip = 1;
1629 return RDCOST(x->rdmult, x->rddiv, rd->rate2, rd->distortion2);
1630 }
1631 }
1632 }
1633 }
1634
1635 /* Add in the Mv/mode cost */
1636 rd->rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
1637
1638 /* Y cost and distortion */
1639 macro_block_yrd(x, &rd->rate_y, &distortion);
1640 rd->rate2 += rd->rate_y;
1641 rd->distortion2 += distortion;
1642
1643 /* UV cost and distortion */
1644 rd_inter16x16_uv(cpi, x, &rd->rate_uv, &rd->distortion_uv,
1645 cpi->common.full_pixel);
1646 rd->rate2 += rd->rate_uv;
1647 rd->distortion2 += rd->distortion_uv;
1648 return INT_MAX;
1649 }
1650
calculate_final_rd_costs(int this_rd,RATE_DISTORTION * rd,int * other_cost,int disable_skip,int uv_intra_tteob,int intra_rd_penalty,VP8_COMP * cpi,MACROBLOCK * x)1651 static int calculate_final_rd_costs(int this_rd, RATE_DISTORTION *rd,
1652 int *other_cost, int disable_skip,
1653 int uv_intra_tteob, int intra_rd_penalty,
1654 VP8_COMP *cpi, MACROBLOCK *x) {
1655 MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode;
1656
1657 /* Where skip is allowable add in the default per mb cost for the no
1658 * skip case. where we then decide to skip we have to delete this and
1659 * replace it with the cost of signalling a skip
1660 */
1661 if (cpi->common.mb_no_coeff_skip) {
1662 *other_cost += vp8_cost_bit(cpi->prob_skip_false, 0);
1663 rd->rate2 += *other_cost;
1664 }
1665
1666 /* Estimate the reference frame signaling cost and add it
1667 * to the rolling cost variable.
1668 */
1669 rd->rate2 += x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
1670
1671 if (!disable_skip) {
1672 /* Test for the condition where skip block will be activated
1673 * because there are no non zero coefficients and make any
1674 * necessary adjustment for rate
1675 */
1676 if (cpi->common.mb_no_coeff_skip) {
1677 int i;
1678 int tteob;
1679 int has_y2_block = (this_mode != SPLITMV && this_mode != B_PRED);
1680
1681 tteob = 0;
1682 if (has_y2_block) tteob += x->e_mbd.eobs[24];
1683
1684 for (i = 0; i < 16; ++i) tteob += (x->e_mbd.eobs[i] > has_y2_block);
1685
1686 if (x->e_mbd.mode_info_context->mbmi.ref_frame) {
1687 for (i = 16; i < 24; ++i) tteob += x->e_mbd.eobs[i];
1688 } else {
1689 tteob += uv_intra_tteob;
1690 }
1691
1692 if (tteob == 0) {
1693 rd->rate2 -= (rd->rate_y + rd->rate_uv);
1694 /* for best_yrd calculation */
1695 rd->rate_uv = 0;
1696
1697 /* Back out no skip flag costing and add in skip flag costing */
1698 if (cpi->prob_skip_false) {
1699 int prob_skip_cost;
1700
1701 prob_skip_cost = vp8_cost_bit(cpi->prob_skip_false, 1);
1702 prob_skip_cost -= (int)vp8_cost_bit(cpi->prob_skip_false, 0);
1703 rd->rate2 += prob_skip_cost;
1704 *other_cost += prob_skip_cost;
1705 }
1706 }
1707 }
1708 /* Calculate the final RD estimate for this mode */
1709 this_rd = RDCOST(x->rdmult, x->rddiv, rd->rate2, rd->distortion2);
1710 if (this_rd < INT_MAX &&
1711 x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
1712 this_rd += intra_rd_penalty;
1713 }
1714 }
1715 return this_rd;
1716 }
1717
update_best_mode(BEST_MODE * best_mode,int this_rd,RATE_DISTORTION * rd,int other_cost,MACROBLOCK * x)1718 static void update_best_mode(BEST_MODE *best_mode, int this_rd,
1719 RATE_DISTORTION *rd, int other_cost,
1720 MACROBLOCK *x) {
1721 MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode;
1722
1723 other_cost += x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
1724
1725 /* Calculate the final y RD estimate for this mode */
1726 best_mode->yrd =
1727 RDCOST(x->rdmult, x->rddiv, (rd->rate2 - rd->rate_uv - other_cost),
1728 (rd->distortion2 - rd->distortion_uv));
1729
1730 best_mode->rd = this_rd;
1731 memcpy(&best_mode->mbmode, &x->e_mbd.mode_info_context->mbmi,
1732 sizeof(MB_MODE_INFO));
1733 memcpy(&best_mode->partition, x->partition_info, sizeof(PARTITION_INFO));
1734
1735 if ((this_mode == B_PRED) || (this_mode == SPLITMV)) {
1736 int i;
1737 for (i = 0; i < 16; ++i) {
1738 best_mode->bmodes[i] = x->e_mbd.block[i].bmi;
1739 }
1740 }
1741 }
1742
vp8_rd_pick_inter_mode(VP8_COMP * cpi,MACROBLOCK * x,int recon_yoffset,int recon_uvoffset,int * returnrate,int * returndistortion,int * returnintra,int mb_row,int mb_col)1743 void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset,
1744 int recon_uvoffset, int *returnrate,
1745 int *returndistortion, int *returnintra, int mb_row,
1746 int mb_col) {
1747 BLOCK *b = &x->block[0];
1748 BLOCKD *d = &x->e_mbd.block[0];
1749 MACROBLOCKD *xd = &x->e_mbd;
1750 int_mv best_ref_mv_sb[2];
1751 int_mv mode_mv_sb[2][MB_MODE_COUNT];
1752 int_mv best_ref_mv;
1753 int_mv *mode_mv;
1754 MB_PREDICTION_MODE this_mode;
1755 int num00;
1756 int best_mode_index = 0;
1757 BEST_MODE best_mode;
1758
1759 int i;
1760 int mode_index;
1761 int mdcounts[4];
1762 int rate;
1763 RATE_DISTORTION rd;
1764 int uv_intra_rate, uv_intra_distortion, uv_intra_rate_tokenonly;
1765 int uv_intra_tteob = 0;
1766 int uv_intra_done = 0;
1767
1768 MB_PREDICTION_MODE uv_intra_mode = 0;
1769 int_mv mvp;
1770 int near_sadidx[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
1771 int saddone = 0;
1772 /* search range got from mv_pred(). It uses step_param levels. (0-7) */
1773 int sr = 0;
1774
1775 unsigned char *plane[4][3];
1776 int ref_frame_map[4];
1777 int sign_bias = 0;
1778
1779 int intra_rd_penalty =
1780 10 * vp8_dc_quant(cpi->common.base_qindex, cpi->common.y1dc_delta_q);
1781
1782 #if CONFIG_TEMPORAL_DENOISING
1783 unsigned int zero_mv_sse = UINT_MAX, best_sse = UINT_MAX,
1784 best_rd_sse = UINT_MAX;
1785 #endif
1786
1787 mode_mv = mode_mv_sb[sign_bias];
1788 best_ref_mv.as_int = 0;
1789 best_mode.rd = INT_MAX;
1790 best_mode.yrd = INT_MAX;
1791 best_mode.intra_rd = INT_MAX;
1792 memset(mode_mv_sb, 0, sizeof(mode_mv_sb));
1793 memset(&best_mode.mbmode, 0, sizeof(best_mode.mbmode));
1794 memset(&best_mode.bmodes, 0, sizeof(best_mode.bmodes));
1795
1796 /* Setup search priorities */
1797 get_reference_search_order(cpi, ref_frame_map);
1798
1799 /* Check to see if there is at least 1 valid reference frame that we need
1800 * to calculate near_mvs.
1801 */
1802 if (ref_frame_map[1] > 0) {
1803 sign_bias = vp8_find_near_mvs_bias(
1804 &x->e_mbd, x->e_mbd.mode_info_context, mode_mv_sb, best_ref_mv_sb,
1805 mdcounts, ref_frame_map[1], cpi->common.ref_frame_sign_bias);
1806
1807 mode_mv = mode_mv_sb[sign_bias];
1808 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
1809 }
1810
1811 get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset);
1812
1813 *returnintra = INT_MAX;
1814 /* Count of the number of MBs tested so far this frame */
1815 x->mbs_tested_so_far++;
1816
1817 x->skip = 0;
1818
1819 for (mode_index = 0; mode_index < MAX_MODES; ++mode_index) {
1820 int this_rd = INT_MAX;
1821 int disable_skip = 0;
1822 int other_cost = 0;
1823 int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]];
1824
1825 /* Test best rd so far against threshold for trying this mode. */
1826 if (best_mode.rd <= x->rd_threshes[mode_index]) continue;
1827
1828 if (this_ref_frame < 0) continue;
1829
1830 /* These variables hold are rolling total cost and distortion for
1831 * this mode
1832 */
1833 rd.rate2 = 0;
1834 rd.distortion2 = 0;
1835
1836 this_mode = vp8_mode_order[mode_index];
1837
1838 x->e_mbd.mode_info_context->mbmi.mode = this_mode;
1839 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
1840
1841 /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
1842 * unless ARNR filtering is enabled in which case we want
1843 * an unfiltered alternative
1844 */
1845 if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {
1846 if (this_mode != ZEROMV ||
1847 x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) {
1848 continue;
1849 }
1850 }
1851
1852 /* everything but intra */
1853 if (x->e_mbd.mode_info_context->mbmi.ref_frame) {
1854 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
1855 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
1856 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
1857
1858 if (sign_bias != cpi->common.ref_frame_sign_bias[this_ref_frame]) {
1859 sign_bias = cpi->common.ref_frame_sign_bias[this_ref_frame];
1860 mode_mv = mode_mv_sb[sign_bias];
1861 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
1862 }
1863 }
1864
1865 /* Check to see if the testing frequency for this mode is at its
1866 * max If so then prevent it from being tested and increase the
1867 * threshold for its testing
1868 */
1869 if (x->mode_test_hit_counts[mode_index] &&
1870 (cpi->mode_check_freq[mode_index] > 1)) {
1871 if (x->mbs_tested_so_far <= cpi->mode_check_freq[mode_index] *
1872 x->mode_test_hit_counts[mode_index]) {
1873 /* Increase the threshold for coding this mode to make it
1874 * less likely to be chosen
1875 */
1876 x->rd_thresh_mult[mode_index] += 4;
1877
1878 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {
1879 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1880 }
1881
1882 x->rd_threshes[mode_index] =
1883 (cpi->rd_baseline_thresh[mode_index] >> 7) *
1884 x->rd_thresh_mult[mode_index];
1885
1886 continue;
1887 }
1888 }
1889
1890 /* We have now reached the point where we are going to test the
1891 * current mode so increment the counter for the number of times
1892 * it has been tested
1893 */
1894 x->mode_test_hit_counts[mode_index]++;
1895
1896 /* Experimental code. Special case for gf and arf zeromv modes.
1897 * Increase zbin size to supress noise
1898 */
1899 if (x->zbin_mode_boost_enabled) {
1900 if (this_ref_frame == INTRA_FRAME) {
1901 x->zbin_mode_boost = 0;
1902 } else {
1903 if (vp8_mode_order[mode_index] == ZEROMV) {
1904 if (this_ref_frame != LAST_FRAME) {
1905 x->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1906 } else {
1907 x->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
1908 }
1909 } else if (vp8_mode_order[mode_index] == SPLITMV) {
1910 x->zbin_mode_boost = 0;
1911 } else {
1912 x->zbin_mode_boost = MV_ZBIN_BOOST;
1913 }
1914 }
1915
1916 vp8_update_zbin_extra(cpi, x);
1917 }
1918
1919 if (!uv_intra_done && this_ref_frame == INTRA_FRAME) {
1920 rd_pick_intra_mbuv_mode(x, &uv_intra_rate, &uv_intra_rate_tokenonly,
1921 &uv_intra_distortion);
1922 uv_intra_mode = x->e_mbd.mode_info_context->mbmi.uv_mode;
1923
1924 /*
1925 * Total of the eobs is used later to further adjust rate2. Since uv
1926 * block's intra eobs will be overwritten when we check inter modes,
1927 * we need to save uv_intra_tteob here.
1928 */
1929 for (i = 16; i < 24; ++i) uv_intra_tteob += x->e_mbd.eobs[i];
1930
1931 uv_intra_done = 1;
1932 }
1933
1934 switch (this_mode) {
1935 case B_PRED: {
1936 int tmp_rd;
1937
1938 /* Note the rate value returned here includes the cost of
1939 * coding the BPRED mode: x->mbmode_cost[x->e_mbd.frame_type][BPRED]
1940 */
1941 int distortion;
1942 tmp_rd = rd_pick_intra4x4mby_modes(x, &rate, &rd.rate_y, &distortion,
1943 best_mode.yrd);
1944 rd.rate2 += rate;
1945 rd.distortion2 += distortion;
1946
1947 if (tmp_rd < best_mode.yrd) {
1948 rd.rate2 += uv_intra_rate;
1949 rd.rate_uv = uv_intra_rate_tokenonly;
1950 rd.distortion2 += uv_intra_distortion;
1951 rd.distortion_uv = uv_intra_distortion;
1952 } else {
1953 this_rd = INT_MAX;
1954 disable_skip = 1;
1955 }
1956 break;
1957 }
1958
1959 case SPLITMV: {
1960 int tmp_rd;
1961 int this_rd_thresh;
1962 int distortion;
1963
1964 this_rd_thresh = (vp8_ref_frame_order[mode_index] == 1)
1965 ? x->rd_threshes[THR_NEW1]
1966 : x->rd_threshes[THR_NEW3];
1967 this_rd_thresh = (vp8_ref_frame_order[mode_index] == 2)
1968 ? x->rd_threshes[THR_NEW2]
1969 : this_rd_thresh;
1970
1971 tmp_rd = vp8_rd_pick_best_mbsegmentation(
1972 cpi, x, &best_ref_mv, best_mode.yrd, mdcounts, &rate, &rd.rate_y,
1973 &distortion, this_rd_thresh);
1974
1975 rd.rate2 += rate;
1976 rd.distortion2 += distortion;
1977
1978 /* If even the 'Y' rd value of split is higher than best so far
1979 * then dont bother looking at UV
1980 */
1981 if (tmp_rd < best_mode.yrd) {
1982 /* Now work out UV cost and add it in */
1983 rd_inter4x4_uv(cpi, x, &rd.rate_uv, &rd.distortion_uv,
1984 cpi->common.full_pixel);
1985 rd.rate2 += rd.rate_uv;
1986 rd.distortion2 += rd.distortion_uv;
1987 } else {
1988 this_rd = INT_MAX;
1989 disable_skip = 1;
1990 }
1991 break;
1992 }
1993 case DC_PRED:
1994 case V_PRED:
1995 case H_PRED:
1996 case TM_PRED: {
1997 int distortion;
1998 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1999
2000 vp8_build_intra_predictors_mby_s(
2001 xd, xd->dst.y_buffer - xd->dst.y_stride, xd->dst.y_buffer - 1,
2002 xd->dst.y_stride, xd->predictor, 16);
2003 macro_block_yrd(x, &rd.rate_y, &distortion);
2004 rd.rate2 += rd.rate_y;
2005 rd.distortion2 += distortion;
2006 rd.rate2 += x->mbmode_cost[x->e_mbd.frame_type]
2007 [x->e_mbd.mode_info_context->mbmi.mode];
2008 rd.rate2 += uv_intra_rate;
2009 rd.rate_uv = uv_intra_rate_tokenonly;
2010 rd.distortion2 += uv_intra_distortion;
2011 rd.distortion_uv = uv_intra_distortion;
2012 break;
2013 }
2014
2015 case NEWMV: {
2016 int thissme;
2017 int bestsme = INT_MAX;
2018 int step_param = cpi->sf.first_step;
2019 int further_steps;
2020 int n;
2021 /* If last step (1-away) of n-step search doesn't pick the center point
2022 as the best match, we will do a final 1-away diamond refining search
2023 */
2024 int do_refine = 1;
2025
2026 int sadpb = x->sadperbit16;
2027 int_mv mvp_full;
2028
2029 int col_min = ((best_ref_mv.as_mv.col + 7) >> 3) - MAX_FULL_PEL_VAL;
2030 int row_min = ((best_ref_mv.as_mv.row + 7) >> 3) - MAX_FULL_PEL_VAL;
2031 int col_max = (best_ref_mv.as_mv.col >> 3) + MAX_FULL_PEL_VAL;
2032 int row_max = (best_ref_mv.as_mv.row >> 3) + MAX_FULL_PEL_VAL;
2033
2034 int tmp_col_min = x->mv_col_min;
2035 int tmp_col_max = x->mv_col_max;
2036 int tmp_row_min = x->mv_row_min;
2037 int tmp_row_max = x->mv_row_max;
2038
2039 if (!saddone) {
2040 vp8_cal_sad(cpi, xd, x, recon_yoffset, &near_sadidx[0]);
2041 saddone = 1;
2042 }
2043
2044 vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, &mvp,
2045 x->e_mbd.mode_info_context->mbmi.ref_frame,
2046 cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
2047
2048 mvp_full.as_mv.col = mvp.as_mv.col >> 3;
2049 mvp_full.as_mv.row = mvp.as_mv.row >> 3;
2050
2051 /* Get intersection of UMV window and valid MV window to
2052 * reduce # of checks in diamond search.
2053 */
2054 if (x->mv_col_min < col_min) x->mv_col_min = col_min;
2055 if (x->mv_col_max > col_max) x->mv_col_max = col_max;
2056 if (x->mv_row_min < row_min) x->mv_row_min = row_min;
2057 if (x->mv_row_max > row_max) x->mv_row_max = row_max;
2058
2059 /* adjust search range according to sr from mv prediction */
2060 if (sr > step_param) step_param = sr;
2061
2062 /* Initial step/diamond search */
2063 {
2064 bestsme = cpi->diamond_search_sad(
2065 x, b, d, &mvp_full, &d->bmi.mv, step_param, sadpb, &num00,
2066 &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
2067 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
2068
2069 /* Further step/diamond searches as necessary */
2070 further_steps = (cpi->sf.max_step_search_steps - 1) - step_param;
2071
2072 n = num00;
2073 num00 = 0;
2074
2075 /* If there won't be more n-step search, check to see if refining
2076 * search is needed. */
2077 if (n > further_steps) do_refine = 0;
2078
2079 while (n < further_steps) {
2080 n++;
2081
2082 if (num00) {
2083 num00--;
2084 } else {
2085 thissme = cpi->diamond_search_sad(
2086 x, b, d, &mvp_full, &d->bmi.mv, step_param + n, sadpb, &num00,
2087 &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
2088
2089 /* check to see if refining search is needed. */
2090 if (num00 > (further_steps - n)) do_refine = 0;
2091
2092 if (thissme < bestsme) {
2093 bestsme = thissme;
2094 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
2095 } else {
2096 d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
2097 }
2098 }
2099 }
2100 }
2101
2102 /* final 1-away diamond refining search */
2103 if (do_refine == 1) {
2104 int search_range;
2105
2106 search_range = 8;
2107
2108 thissme = cpi->refining_search_sad(
2109 x, b, d, &d->bmi.mv, sadpb, search_range,
2110 &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
2111
2112 if (thissme < bestsme) {
2113 bestsme = thissme;
2114 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
2115 } else {
2116 d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
2117 }
2118 }
2119
2120 x->mv_col_min = tmp_col_min;
2121 x->mv_col_max = tmp_col_max;
2122 x->mv_row_min = tmp_row_min;
2123 x->mv_row_max = tmp_row_max;
2124
2125 if (bestsme < INT_MAX) {
2126 int dis; /* TODO: use dis in distortion calculation later. */
2127 unsigned int sse;
2128 cpi->find_fractional_mv_step(
2129 x, b, d, &d->bmi.mv, &best_ref_mv, x->errorperbit,
2130 &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &dis, &sse);
2131 }
2132
2133 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
2134
2135 /* Add the new motion vector cost to our rolling cost variable */
2136 rd.rate2 +=
2137 vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96);
2138 }
2139
2140 case NEARESTMV:
2141 case NEARMV:
2142 /* Clip "next_nearest" so that it does not extend to far out
2143 * of image
2144 */
2145 vp8_clamp_mv2(&mode_mv[this_mode], xd);
2146
2147 /* Do not bother proceeding if the vector (from newmv, nearest
2148 * or near) is 0,0 as this should then be coded using the zeromv
2149 * mode.
2150 */
2151 if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) &&
2152 (mode_mv[this_mode].as_int == 0)) {
2153 continue;
2154 }
2155
2156 case ZEROMV:
2157
2158 /* Trap vectors that reach beyond the UMV borders
2159 * Note that ALL New MV, Nearest MV Near MV and Zero MV code
2160 * drops through to this point because of the lack of break
2161 * statements in the previous two cases.
2162 */
2163 if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
2164 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
2165 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
2166 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) {
2167 continue;
2168 }
2169
2170 vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);
2171 this_rd = evaluate_inter_mode_rd(mdcounts, &rd, &disable_skip, cpi, x);
2172 break;
2173
2174 default: break;
2175 }
2176
2177 this_rd =
2178 calculate_final_rd_costs(this_rd, &rd, &other_cost, disable_skip,
2179 uv_intra_tteob, intra_rd_penalty, cpi, x);
2180
2181 /* Keep record of best intra distortion */
2182 if ((x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) &&
2183 (this_rd < best_mode.intra_rd)) {
2184 best_mode.intra_rd = this_rd;
2185 *returnintra = rd.distortion2;
2186 }
2187 #if CONFIG_TEMPORAL_DENOISING
2188 if (cpi->oxcf.noise_sensitivity) {
2189 unsigned int sse;
2190 vp8_get_inter_mbpred_error(x, &cpi->fn_ptr[BLOCK_16X16], &sse,
2191 mode_mv[this_mode]);
2192
2193 if (sse < best_rd_sse) best_rd_sse = sse;
2194
2195 /* Store for later use by denoiser. */
2196 if (this_mode == ZEROMV && sse < zero_mv_sse) {
2197 zero_mv_sse = sse;
2198 x->best_zeromv_reference_frame =
2199 x->e_mbd.mode_info_context->mbmi.ref_frame;
2200 }
2201
2202 /* Store the best NEWMV in x for later use in the denoiser. */
2203 if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV && sse < best_sse) {
2204 best_sse = sse;
2205 vp8_get_inter_mbpred_error(x, &cpi->fn_ptr[BLOCK_16X16], &best_sse,
2206 mode_mv[this_mode]);
2207 x->best_sse_inter_mode = NEWMV;
2208 x->best_sse_mv = x->e_mbd.mode_info_context->mbmi.mv;
2209 x->need_to_clamp_best_mvs =
2210 x->e_mbd.mode_info_context->mbmi.need_to_clamp_mvs;
2211 x->best_reference_frame = x->e_mbd.mode_info_context->mbmi.ref_frame;
2212 }
2213 }
2214 #endif
2215
2216 /* Did this mode help.. i.i is it the new best mode */
2217 if (this_rd < best_mode.rd || x->skip) {
2218 /* Note index of best mode so far */
2219 best_mode_index = mode_index;
2220 *returnrate = rd.rate2;
2221 *returndistortion = rd.distortion2;
2222 if (this_mode <= B_PRED) {
2223 x->e_mbd.mode_info_context->mbmi.uv_mode = uv_intra_mode;
2224 /* required for left and above block mv */
2225 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2226 }
2227 update_best_mode(&best_mode, this_rd, &rd, other_cost, x);
2228
2229 /* Testing this mode gave rise to an improvement in best error
2230 * score. Lower threshold a bit for next time
2231 */
2232 x->rd_thresh_mult[mode_index] =
2233 (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2))
2234 ? x->rd_thresh_mult[mode_index] - 2
2235 : MIN_THRESHMULT;
2236 }
2237
2238 /* If the mode did not help improve the best error case then raise
2239 * the threshold for testing that mode next time around.
2240 */
2241 else {
2242 x->rd_thresh_mult[mode_index] += 4;
2243
2244 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {
2245 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
2246 }
2247 }
2248 x->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) *
2249 x->rd_thresh_mult[mode_index];
2250
2251 if (x->skip) break;
2252 }
2253
2254 /* Reduce the activation RD thresholds for the best choice mode */
2255 if ((cpi->rd_baseline_thresh[best_mode_index] > 0) &&
2256 (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2))) {
2257 int best_adjustment = (x->rd_thresh_mult[best_mode_index] >> 2);
2258
2259 x->rd_thresh_mult[best_mode_index] =
2260 (x->rd_thresh_mult[best_mode_index] >=
2261 (MIN_THRESHMULT + best_adjustment))
2262 ? x->rd_thresh_mult[best_mode_index] - best_adjustment
2263 : MIN_THRESHMULT;
2264 x->rd_threshes[best_mode_index] =
2265 (cpi->rd_baseline_thresh[best_mode_index] >> 7) *
2266 x->rd_thresh_mult[best_mode_index];
2267 }
2268
2269 #if CONFIG_TEMPORAL_DENOISING
2270 if (cpi->oxcf.noise_sensitivity) {
2271 int block_index = mb_row * cpi->common.mb_cols + mb_col;
2272 if (x->best_sse_inter_mode == DC_PRED) {
2273 /* No best MV found. */
2274 x->best_sse_inter_mode = best_mode.mbmode.mode;
2275 x->best_sse_mv = best_mode.mbmode.mv;
2276 x->need_to_clamp_best_mvs = best_mode.mbmode.need_to_clamp_mvs;
2277 x->best_reference_frame = best_mode.mbmode.ref_frame;
2278 best_sse = best_rd_sse;
2279 }
2280 vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse,
2281 recon_yoffset, recon_uvoffset, &cpi->common.lf_info,
2282 mb_row, mb_col, block_index, 0);
2283
2284 /* Reevaluate ZEROMV after denoising. */
2285 if (best_mode.mbmode.ref_frame == INTRA_FRAME &&
2286 x->best_zeromv_reference_frame != INTRA_FRAME) {
2287 int this_rd = INT_MAX;
2288 int disable_skip = 0;
2289 int other_cost = 0;
2290 int this_ref_frame = x->best_zeromv_reference_frame;
2291 rd.rate2 =
2292 x->ref_frame_cost[this_ref_frame] + vp8_cost_mv_ref(ZEROMV, mdcounts);
2293 rd.distortion2 = 0;
2294
2295 /* set up the proper prediction buffers for the frame */
2296 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
2297 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
2298 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
2299 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
2300
2301 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
2302 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
2303 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2304
2305 this_rd = evaluate_inter_mode_rd(mdcounts, &rd, &disable_skip, cpi, x);
2306 this_rd =
2307 calculate_final_rd_costs(this_rd, &rd, &other_cost, disable_skip,
2308 uv_intra_tteob, intra_rd_penalty, cpi, x);
2309 if (this_rd < best_mode.rd || x->skip) {
2310 *returnrate = rd.rate2;
2311 *returndistortion = rd.distortion2;
2312 update_best_mode(&best_mode, this_rd, &rd, other_cost, x);
2313 }
2314 }
2315 }
2316 #endif
2317
2318 if (cpi->is_src_frame_alt_ref &&
2319 (best_mode.mbmode.mode != ZEROMV ||
2320 best_mode.mbmode.ref_frame != ALTREF_FRAME)) {
2321 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
2322 x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME;
2323 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2324 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
2325 x->e_mbd.mode_info_context->mbmi.mb_skip_coeff =
2326 (cpi->common.mb_no_coeff_skip);
2327 x->e_mbd.mode_info_context->mbmi.partitioning = 0;
2328 return;
2329 }
2330
2331 /* macroblock modes */
2332 memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mode.mbmode,
2333 sizeof(MB_MODE_INFO));
2334
2335 if (best_mode.mbmode.mode == B_PRED) {
2336 for (i = 0; i < 16; ++i) {
2337 xd->mode_info_context->bmi[i].as_mode = best_mode.bmodes[i].as_mode;
2338 }
2339 }
2340
2341 if (best_mode.mbmode.mode == SPLITMV) {
2342 for (i = 0; i < 16; ++i) {
2343 xd->mode_info_context->bmi[i].mv.as_int = best_mode.bmodes[i].mv.as_int;
2344 }
2345
2346 memcpy(x->partition_info, &best_mode.partition, sizeof(PARTITION_INFO));
2347
2348 x->e_mbd.mode_info_context->mbmi.mv.as_int =
2349 x->partition_info->bmi[15].mv.as_int;
2350 }
2351
2352 if (sign_bias !=
2353 cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) {
2354 best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
2355 }
2356
2357 rd_update_mvcount(x, &best_ref_mv);
2358 }
2359
vp8_rd_pick_intra_mode(MACROBLOCK * x,int * rate_)2360 void vp8_rd_pick_intra_mode(MACROBLOCK *x, int *rate_) {
2361 int error4x4, error16x16;
2362 int rate4x4, rate16x16 = 0, rateuv;
2363 int dist4x4, dist16x16, distuv;
2364 int rate;
2365 int rate4x4_tokenonly = 0;
2366 int rate16x16_tokenonly = 0;
2367 int rateuv_tokenonly = 0;
2368
2369 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
2370
2371 rd_pick_intra_mbuv_mode(x, &rateuv, &rateuv_tokenonly, &distuv);
2372 rate = rateuv;
2373
2374 error16x16 = rd_pick_intra16x16mby_mode(x, &rate16x16, &rate16x16_tokenonly,
2375 &dist16x16);
2376
2377 error4x4 = rd_pick_intra4x4mby_modes(x, &rate4x4, &rate4x4_tokenonly,
2378 &dist4x4, error16x16);
2379
2380 if (error4x4 < error16x16) {
2381 x->e_mbd.mode_info_context->mbmi.mode = B_PRED;
2382 rate += rate4x4;
2383 } else {
2384 rate += rate16x16;
2385 }
2386
2387 *rate_ = rate;
2388 }
2389