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