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