?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
clarify *_offsets.asm differences
[libvpx.git] / vp8 / encoder / rdopt.c
blobea21cf4526d70d999d3d1c23db8dd0b2b1cc7e38
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 int distortion;
712 int best_rd = INT_MAX;
713 int this_rd;
714
715 //Y Search for 16x16 intra prediction mode
716 for (mode = DC_PRED; mode <= TM_PRED; mode++)
717 {
718 x->e_mbd.mode_info_context->mbmi.mode = mode;
719
720 vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
721
722 macro_block_yrd(x, &ratey, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
723 rate = ratey + x->mbmode_cost[x->e_mbd.frame_type]
724 [x->e_mbd.mode_info_context->mbmi.mode];
725
726 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
727
728 if (this_rd < best_rd)
729 {
730 mode_selected = mode;
731 best_rd = this_rd;
732 *Rate = rate;
733 *rate_y = ratey;
734 *Distortion = distortion;
735 }
736 }
737
738 x->e_mbd.mode_info_context->mbmi.mode = mode_selected;
739 return best_rd;
740 }
741
742 static int rd_cost_mbuv(MACROBLOCK *mb)
743 {
744 int b;
745 int cost = 0;
746 MACROBLOCKD *x = &mb->e_mbd;
747 ENTROPY_CONTEXT_PLANES t_above, t_left;
748 ENTROPY_CONTEXT *ta;
749 ENTROPY_CONTEXT *tl;
750
751 vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
752 vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
753
754 ta = (ENTROPY_CONTEXT *)&t_above;
755 tl = (ENTROPY_CONTEXT *)&t_left;
756
757 for (b = 16; b < 20; b++)
758 cost += cost_coeffs(mb, x->block + b, vp8_block2type[b],
759 ta + vp8_block2above[b], tl + vp8_block2left[b]);
760
761 for (b = 20; b < 24; b++)
762 cost += cost_coeffs(mb, x->block + b, vp8_block2type[b],
763 ta + vp8_block2above[b], tl + vp8_block2left[b]);
764
765 return cost;
766 }
767
768
769 unsigned int vp8_get_mbuvrecon_error(const vp8_variance_rtcd_vtable_t *rtcd, const MACROBLOCK *x) // sum of squares
770 {
771 unsigned int sse0, sse1;
772 int sum0, sum1;
773 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);
774 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);
775 return (sse0 + sse1);
776 }
777
778 static int vp8_rd_inter_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *distortion, int fullpixel)
779 {
780 vp8_build_uvmvs(&x->e_mbd, fullpixel);
781 vp8_encode_inter16x16uvrd(IF_RTCD(&cpi->rtcd), x);
782
783
784 *rate = rd_cost_mbuv(x);
785 *distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
786
787 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
788 }
789
790 int vp8_rd_pick_intra_mbuv_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int *distortion)
791 {
792 MB_PREDICTION_MODE mode;
793 MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
794 int best_rd = INT_MAX;
795 int UNINITIALIZED_IS_SAFE(d), UNINITIALIZED_IS_SAFE(r);
796 int rate_to;
797
798 for (mode = DC_PRED; mode <= TM_PRED; mode++)
799 {
800 int rate;
801 int distortion;
802 int this_rd;
803
804 x->e_mbd.mode_info_context->mbmi.uv_mode = mode;
805 vp8_encode_intra16x16mbuvrd(IF_RTCD(&cpi->rtcd), x);
806
807 rate_to = rd_cost_mbuv(x);
808 rate = rate_to + x->intra_uv_mode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.uv_mode];
809
810 distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
811
812 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
813
814 if (this_rd < best_rd)
815 {
816 best_rd = this_rd;
817 d = distortion;
818 r = rate;
819 *rate_tokenonly = rate_to;
820 mode_selected = mode;
821 }
822 }
823
824 *rate = r;
825 *distortion = d;
826
827 x->e_mbd.mode_info_context->mbmi.uv_mode = mode_selected;
828 return best_rd;
829 }
830 #endif
831
832 int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
833 {
834 vp8_prob p [VP8_MVREFS-1];
835 assert(NEARESTMV <= m && m <= SPLITMV);
836 vp8_mv_ref_probs(p, near_mv_ref_ct);
837 return vp8_cost_token(vp8_mv_ref_tree, p,
838 vp8_mv_ref_encoding_array - NEARESTMV + m);
839 }
840
841 void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv)
842 {
843 int i;
844
845 x->e_mbd.mode_info_context->mbmi.mode = mb;
846 x->e_mbd.mode_info_context->mbmi.mv.as_mv.row = mv->row;
847 x->e_mbd.mode_info_context->mbmi.mv.as_mv.col = mv->col;
848
849 for (i = 0; i < 16; i++)
850 {
851 B_MODE_INFO *bmi = &x->e_mbd.block[i].bmi;
852 bmi->mode = (B_PREDICTION_MODE) mb;
853 bmi->mv.as_mv.row = mv->row;
854 bmi->mv.as_mv.col = mv->col;
855 }
856 }
857
858 #if !(CONFIG_REALTIME_ONLY)
859 static int labels2mode(
860 MACROBLOCK *x,
861 int const *labelings, int which_label,
862 B_PREDICTION_MODE this_mode,
863 MV *this_mv, MV *best_ref_mv,
864 int *mvcost[2]
865 )
866 {
867 MACROBLOCKD *const xd = & x->e_mbd;
868 MODE_INFO *const mic = xd->mode_info_context;
869 const int mis = xd->mode_info_stride;
870
871 int cost = 0;
872 int thismvcost = 0;
873
874 /* We have to be careful retrieving previously-encoded motion vectors.
875 Ones from this macroblock have to be pulled from the BLOCKD array
876 as they have not yet made it to the bmi array in our MB_MODE_INFO. */
877
878 int i = 0;
879
880 do
881 {
882 BLOCKD *const d = xd->block + i;
883 const int row = i >> 2, col = i & 3;
884
885 B_PREDICTION_MODE m;
886
887 if (labelings[i] != which_label)
888 continue;
889
890 if (col && labelings[i] == labelings[i-1])
891 m = LEFT4X4;
892 else if (row && labelings[i] == labelings[i-4])
893 m = ABOVE4X4;
894 else
895 {
896 // the only time we should do costing for new motion vector or mode
897 // is when we are on a new label (jbb May 08, 2007)
898 switch (m = this_mode)
899 {
900 case NEW4X4 :
901 thismvcost = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
902 break;
903 case LEFT4X4:
904 *this_mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
905 break;
906 case ABOVE4X4:
907 *this_mv = row ? d[-4].bmi.mv.as_mv : vp8_above_bmi(mic, i, mis)->mv.as_mv;
908 break;
909 case ZERO4X4:
910 this_mv->row = this_mv->col = 0;
911 break;
912 default:
913 break;
914 }
915
916 if (m == ABOVE4X4) // replace above with left if same
917 {
918 const MV mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
919
920 if (mv.row == this_mv->row && mv.col == this_mv->col)
921 m = LEFT4X4;
922 }
923
924 cost = x->inter_bmode_costs[ m];
925 }
926
927 d->bmi.mode = m;
928 d->bmi.mv.as_mv = *this_mv;
929
930 }
931 while (++i < 16);
932
933 cost += thismvcost ;
934 return cost;
935 }
936
937 static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels,
938 int which_label, ENTROPY_CONTEXT *ta,
939 ENTROPY_CONTEXT *tl)
940 {
941 int cost = 0;
942 int b;
943 MACROBLOCKD *x = &mb->e_mbd;
944
945 for (b = 0; b < 16; b++)
946 if (labels[ b] == which_label)
947 cost += cost_coeffs(mb, x->block + b, 3,
948 ta + vp8_block2above[b],
949 tl + vp8_block2left[b]);
950
951 return cost;
952
953 }
954 static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, int const *labels, int which_label, const vp8_encodemb_rtcd_vtable_t *rtcd)
955 {
956 int i;
957 unsigned int distortion = 0;
958
959 for (i = 0; i < 16; i++)
960 {
961 if (labels[i] == which_label)
962 {
963 BLOCKD *bd = &x->e_mbd.block[i];
964 BLOCK *be = &x->block[i];
965
966
967 vp8_build_inter_predictors_b(bd, 16, x->e_mbd.subpixel_predict);
968 ENCODEMB_INVOKE(rtcd, subb)(be, bd, 16);
969 x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
970
971 // set to 0 no way to account for 2nd order DC so discount
972 //be->coeff[0] = 0;
973 x->quantize_b(be, bd);
974
975 distortion += ENCODEMB_INVOKE(rtcd, berr)(be->coeff, bd->dqcoeff);
976 }
977 }
978
979 return distortion;
980 }
981
982 unsigned char vp8_mbsplit_offset2[4][16] = {
983 { 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
984 { 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
985 { 0, 2, 8, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
986 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
987 };
988
989
990 static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};
991
992
993 typedef struct
994 {
995 MV *ref_mv;
996 MV *mvp;
997
998 int segment_rd;
999 int segment_num;
1000 int r;
1001 int d;
1002 int segment_yrate;
1003 B_PREDICTION_MODE modes[16];
1004 int_mv mvs[16];
1005 unsigned char eobs[16];
1006
1007 int mvthresh;
1008 int *mdcounts;
1009
1010 MV sv_mvp[4]; // save 4 mvp from 8x8
1011 int sv_istep[2]; // save 2 initial step_param for 16x8/8x16
1012
1013 } BEST_SEG_INFO;
1014
1015
1016 void vp8_rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x, BEST_SEG_INFO *bsi,
1017 unsigned int segmentation)
1018 {
1019 int i;
1020 int const *labels;
1021 int br = 0;
1022 int bd = 0;
1023 B_PREDICTION_MODE this_mode;
1024
1025
1026 int label_count;
1027 int this_segment_rd = 0;
1028 int label_mv_thresh;
1029 int rate = 0;
1030 int sbr = 0;
1031 int sbd = 0;
1032 int segmentyrate = 0;
1033
1034 vp8_variance_fn_ptr_t *v_fn_ptr;
1035
1036 ENTROPY_CONTEXT_PLANES t_above, t_left;
1037 ENTROPY_CONTEXT *ta;
1038 ENTROPY_CONTEXT *tl;
1039 ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
1040 ENTROPY_CONTEXT *ta_b;
1041 ENTROPY_CONTEXT *tl_b;
1042
1043 vpx_memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
1044 vpx_memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
1045
1046 ta = (ENTROPY_CONTEXT *)&t_above;
1047 tl = (ENTROPY_CONTEXT *)&t_left;
1048 ta_b = (ENTROPY_CONTEXT *)&t_above_b;
1049 tl_b = (ENTROPY_CONTEXT *)&t_left_b;
1050
1051 br = 0;
1052 bd = 0;
1053
1054 v_fn_ptr = &cpi->fn_ptr[segmentation];
1055 labels = vp8_mbsplits[segmentation];
1056 label_count = vp8_mbsplit_count[segmentation];
1057
1058 // 64 makes this threshold really big effectively
1059 // making it so that we very rarely check mvs on
1060 // segments. setting this to 1 would make mv thresh
1061 // roughly equal to what it is for macroblocks
1062 label_mv_thresh = 1 * bsi->mvthresh / label_count ;
1063
1064 // Segmentation method overheads
1065 rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + segmentation);
1066 rate += vp8_cost_mv_ref(SPLITMV, bsi->mdcounts);
1067 this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
1068 br += rate;
1069
1070 for (i = 0; i < label_count; i++)
1071 {
1072 MV mode_mv[B_MODE_COUNT];
1073 int best_label_rd = INT_MAX;
1074 B_PREDICTION_MODE mode_selected = ZERO4X4;
1075 int bestlabelyrate = 0;
1076
1077 // search for the best motion vector on this segment
1078 for (this_mode = LEFT4X4; this_mode <= NEW4X4 ; this_mode ++)
1079 {
1080 int this_rd;
1081 int distortion;
1082 int labelyrate;
1083 ENTROPY_CONTEXT_PLANES t_above_s, t_left_s;
1084 ENTROPY_CONTEXT *ta_s;
1085 ENTROPY_CONTEXT *tl_s;
1086
1087 vpx_memcpy(&t_above_s, &t_above, sizeof(ENTROPY_CONTEXT_PLANES));
1088 vpx_memcpy(&t_left_s, &t_left, sizeof(ENTROPY_CONTEXT_PLANES));
1089
1090 ta_s = (ENTROPY_CONTEXT *)&t_above_s;
1091 tl_s = (ENTROPY_CONTEXT *)&t_left_s;
1092
1093 if (this_mode == NEW4X4)
1094 {
1095 int sseshift;
1096 int num00;
1097 int step_param = 0;
1098 int further_steps;
1099 int n;
1100 int thissme;
1101 int bestsme = INT_MAX;
1102 MV temp_mv;
1103 BLOCK *c;
1104 BLOCKD *e;
1105
1106 // Is the best so far sufficiently good that we cant justify doing and new motion search.
1107 if (best_label_rd < label_mv_thresh)
1108 break;
1109
1110 if(cpi->compressor_speed)
1111 {
1112 if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8)
1113 {
1114 bsi->mvp = &bsi->sv_mvp[i];
1115 if (i==1 && segmentation == BLOCK_16X8) bsi->mvp = &bsi->sv_mvp[2];
1116
1117 step_param = bsi->sv_istep[i];
1118 }
1119
1120 // use previous block's result as next block's MV predictor.
1121 if (segmentation == BLOCK_4X4 && i>0)
1122 {
1123 bsi->mvp = &(x->e_mbd.block[i-1].bmi.mv.as_mv);
1124 if (i==4 || i==8 || i==12) bsi->mvp = &(x->e_mbd.block[i-4].bmi.mv.as_mv);
1125 step_param = 2;
1126 }
1127 }
1128
1129 further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
1130
1131 {
1132 int sadpb = x->sadperbit4;
1133
1134 // find first label
1135 n = vp8_mbsplit_offset2[segmentation][i];
1136
1137 c = &x->block[n];
1138 e = &x->e_mbd.block[n];
1139
1140 if (cpi->sf.search_method == HEX)
1141 bestsme = vp8_hex_search(x, c, e, bsi->ref_mv,
1142 &mode_mv[NEW4X4], step_param, sadpb, &num00, v_fn_ptr, x->mvsadcost, x->mvcost);
1143
1144 else
1145 {
1146 bestsme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1147 &mode_mv[NEW4X4], step_param,
1148 sadpb / 2, &num00, v_fn_ptr, x->mvsadcost, x->mvcost, bsi->ref_mv);
1149
1150 n = num00;
1151 num00 = 0;
1152
1153 while (n < further_steps)
1154 {
1155 n++;
1156
1157 if (num00)
1158 num00--;
1159 else
1160 {
1161 thissme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1162 &temp_mv, step_param + n,
1163 sadpb / 2, &num00, v_fn_ptr, x->mvsadcost, x->mvcost, bsi->ref_mv);
1164
1165 if (thissme < bestsme)
1166 {
1167 bestsme = thissme;
1168 mode_mv[NEW4X4].row = temp_mv.row;
1169 mode_mv[NEW4X4].col = temp_mv.col;
1170 }
1171 }
1172 }
1173 }
1174
1175 sseshift = segmentation_to_sseshift[segmentation];
1176
1177 // Should we do a full search (best quality only)
1178 if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000)
1179 {
1180 thissme = cpi->full_search_sad(x, c, e, bsi->mvp,
1181 sadpb / 4, 16, v_fn_ptr, x->mvcost, x->mvsadcost,bsi->ref_mv);
1182
1183 if (thissme < bestsme)
1184 {
1185 bestsme = thissme;
1186 mode_mv[NEW4X4] = e->bmi.mv.as_mv;
1187 }
1188 else
1189 {
1190 // The full search result is actually worse so re-instate the previous best vector
1191 e->bmi.mv.as_mv = mode_mv[NEW4X4];
1192 }
1193 }
1194 }
1195
1196 if (bestsme < INT_MAX)
1197 {
1198 if (!cpi->common.full_pixel)
1199 cpi->find_fractional_mv_step(x, c, e, &mode_mv[NEW4X4],
1200 bsi->ref_mv, x->errorperbit / 2, v_fn_ptr, x->mvcost);
1201 else
1202 vp8_skip_fractional_mv_step(x, c, e, &mode_mv[NEW4X4],
1203 bsi->ref_mv, x->errorperbit, v_fn_ptr, x->mvcost);
1204 }
1205 } /* NEW4X4 */
1206
1207 rate = labels2mode(x, labels, i, this_mode, &mode_mv[this_mode],
1208 bsi->ref_mv, x->mvcost);
1209
1210 // Trap vectors that reach beyond the UMV borders
1211 if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) ||
1212 ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max))
1213 {
1214 continue;
1215 }
1216
1217 distortion = vp8_encode_inter_mb_segment(x, labels, i, IF_RTCD(&cpi->rtcd.encodemb)) / 4;
1218
1219 labelyrate = rdcost_mbsegment_y(x, labels, i, ta_s, tl_s);
1220 rate += labelyrate;
1221
1222 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1223
1224 if (this_rd < best_label_rd)
1225 {
1226 sbr = rate;
1227 sbd = distortion;
1228 bestlabelyrate = labelyrate;
1229 mode_selected = this_mode;
1230 best_label_rd = this_rd;
1231
1232 vpx_memcpy(ta_b, ta_s, sizeof(ENTROPY_CONTEXT_PLANES));
1233 vpx_memcpy(tl_b, tl_s, sizeof(ENTROPY_CONTEXT_PLANES));
1234
1235 }
1236 } /*for each 4x4 mode*/
1237
1238 vpx_memcpy(ta, ta_b, sizeof(ENTROPY_CONTEXT_PLANES));
1239 vpx_memcpy(tl, tl_b, sizeof(ENTROPY_CONTEXT_PLANES));
1240
1241 labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected],
1242 bsi->ref_mv, x->mvcost);
1243
1244 br += sbr;
1245 bd += sbd;
1246 segmentyrate += bestlabelyrate;
1247 this_segment_rd += best_label_rd;
1248
1249 if (this_segment_rd >= bsi->segment_rd)
1250 break;
1251
1252 } /* for each label */
1253
1254 if (this_segment_rd < bsi->segment_rd)
1255 {
1256 bsi->r = br;
1257 bsi->d = bd;
1258 bsi->segment_yrate = segmentyrate;
1259 bsi->segment_rd = this_segment_rd;
1260 bsi->segment_num = segmentation;
1261
1262 // store everything needed to come back to this!!
1263 for (i = 0; i < 16; i++)
1264 {
1265 BLOCKD *bd = &x->e_mbd.block[i];
1266
1267 bsi->mvs[i].as_mv = bd->bmi.mv.as_mv;
1268 bsi->modes[i] = bd->bmi.mode;
1269 bsi->eobs[i] = bd->eob;
1270 }
1271 }
1272 }
1273
1274 static __inline
1275 void vp8_cal_step_param(int sr, int *sp)
1276 {
1277 int step = 0;
1278
1279 if (sr > MAX_FIRST_STEP) sr = MAX_FIRST_STEP;
1280 else if (sr < 1) sr = 1;
1281
1282 while (sr>>=1)
1283 step++;
1284
1285 *sp = MAX_MVSEARCH_STEPS - 1 - step;
1286 }
1287
1288 static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
1289 MV *best_ref_mv, int best_rd,
1290 int *mdcounts, int *returntotrate,
1291 int *returnyrate, int *returndistortion,
1292 int mvthresh)
1293 {
1294 int i;
1295 BEST_SEG_INFO bsi;
1296
1297 vpx_memset(&bsi, 0, sizeof(bsi));
1298
1299 bsi.segment_rd = best_rd;
1300 bsi.ref_mv = best_ref_mv;
1301 bsi.mvp = best_ref_mv;
1302 bsi.mvthresh = mvthresh;
1303 bsi.mdcounts = mdcounts;
1304
1305 for(i = 0; i < 16; i++)
1306 {
1307 bsi.modes[i] = ZERO4X4;
1308 }
1309
1310 if(cpi->compressor_speed == 0)
1311 {
1312 /* for now, we will keep the original segmentation order
1313 when in best quality mode */
1314 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1315 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1316 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1317 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1318 }
1319 else
1320 {
1321 int sr;
1322
1323 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1324
1325 if (bsi.segment_rd < best_rd)
1326 {
1327 int col_min = (best_ref_mv->col - MAX_FULL_PEL_VAL) >>3;
1328 int col_max = (best_ref_mv->col + MAX_FULL_PEL_VAL) >>3;
1329 int row_min = (best_ref_mv->row - MAX_FULL_PEL_VAL) >>3;
1330 int row_max = (best_ref_mv->row + MAX_FULL_PEL_VAL) >>3;
1331
1332 int tmp_col_min = x->mv_col_min;
1333 int tmp_col_max = x->mv_col_max;
1334 int tmp_row_min = x->mv_row_min;
1335 int tmp_row_max = x->mv_row_max;
1336
1337 /* Get intersection of UMV window and valid MV window to reduce # of checks in diamond search. */
1338 if (x->mv_col_min < col_min )
1339 x->mv_col_min = col_min;
1340 if (x->mv_col_max > col_max )
1341 x->mv_col_max = col_max;
1342 if (x->mv_row_min < row_min )
1343 x->mv_row_min = row_min;
1344 if (x->mv_row_max > row_max )
1345 x->mv_row_max = row_max;
1346
1347 /* Get 8x8 result */
1348 bsi.sv_mvp[0] = bsi.mvs[0].as_mv;
1349 bsi.sv_mvp[1] = bsi.mvs[2].as_mv;
1350 bsi.sv_mvp[2] = bsi.mvs[8].as_mv;
1351 bsi.sv_mvp[3] = bsi.mvs[10].as_mv;
1352
1353 /* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range according to the closeness of 2 MV. */
1354 /* block 8X16 */
1355 {
1356 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);
1357 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1358
1359 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);
1360 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1361
1362 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1363 }
1364
1365 /* block 16X8 */
1366 {
1367 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);
1368 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1369
1370 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);
1371 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1372
1373 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1374 }
1375
1376 /* If 8x8 is better than 16x8/8x16, then do 4x4 search */
1377 /* Not skip 4x4 if speed=0 (good quality) */
1378 if (cpi->sf.no_skip_block4x4_search || bsi.segment_num == BLOCK_8X8) /* || (sv_segment_rd8x8-bsi.segment_rd) < sv_segment_rd8x8>>5) */
1379 {
1380 bsi.mvp = &bsi.sv_mvp[0];
1381 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1382 }
1383
1384 /* restore UMV window */
1385 x->mv_col_min = tmp_col_min;
1386 x->mv_col_max = tmp_col_max;
1387 x->mv_row_min = tmp_row_min;
1388 x->mv_row_max = tmp_row_max;
1389 }
1390 }
1391
1392 /* set it to the best */
1393 for (i = 0; i < 16; i++)
1394 {
1395 BLOCKD *bd = &x->e_mbd.block[i];
1396
1397 bd->bmi.mv.as_mv = bsi.mvs[i].as_mv;
1398 bd->bmi.mode = bsi.modes[i];
1399 bd->eob = bsi.eobs[i];
1400 }
1401
1402 *returntotrate = bsi.r;
1403 *returndistortion = bsi.d;
1404 *returnyrate = bsi.segment_yrate;
1405
1406 /* save partitions */
1407 x->e_mbd.mode_info_context->mbmi.partitioning = bsi.segment_num;
1408 x->partition_info->count = vp8_mbsplit_count[bsi.segment_num];
1409
1410 for (i = 0; i < x->partition_info->count; i++)
1411 {
1412 int j;
1413
1414 j = vp8_mbsplit_offset2[bsi.segment_num][i];
1415
1416 x->partition_info->bmi[i].mode = x->e_mbd.block[j].bmi.mode;
1417 x->partition_info->bmi[i].mv.as_mv = x->e_mbd.block[j].bmi.mv.as_mv;
1418 }
1419
1420 return bsi.segment_rd;
1421 }
1422 #endif
1423
1424 static void swap(int *x,int *y)
1425 {
1426 int tmp;
1427
1428 tmp = *x;
1429 *x = *y;
1430 *y = tmp;
1431 }
1432
1433 static void quicksortmv(int arr[],int left, int right)
1434 {
1435 int lidx,ridx,pivot;
1436
1437 lidx = left;
1438 ridx = right;
1439
1440 if( left < right)
1441 {
1442 pivot = (left + right)/2;
1443
1444 while(lidx <=pivot && ridx >=pivot)
1445 {
1446 while(arr[lidx] < arr[pivot] && lidx <= pivot)
1447 lidx++;
1448 while(arr[ridx] > arr[pivot] && ridx >= pivot)
1449 ridx--;
1450 swap(&arr[lidx], &arr[ridx]);
1451 lidx++;
1452 ridx--;
1453 if(lidx-1 == pivot)
1454 {
1455 ridx++;
1456 pivot = ridx;
1457 }
1458 else if(ridx+1 == pivot)
1459 {
1460 lidx--;
1461 pivot = lidx;
1462 }
1463 }
1464 quicksortmv(arr, left, pivot - 1);
1465 quicksortmv(arr, pivot + 1, right);
1466 }
1467 }
1468
1469 static void quicksortsad(int arr[],int idx[], int left, int right)
1470 {
1471 int lidx,ridx,pivot;
1472
1473 lidx = left;
1474 ridx = right;
1475
1476 if( left < right)
1477 {
1478 pivot = (left + right)/2;
1479
1480 while(lidx <=pivot && ridx >=pivot)
1481 {
1482 while(arr[lidx] < arr[pivot] && lidx <= pivot)
1483 lidx++;
1484 while(arr[ridx] > arr[pivot] && ridx >= pivot)
1485 ridx--;
1486 swap(&arr[lidx], &arr[ridx]);
1487 swap(&idx[lidx], &idx[ridx]);
1488 lidx++;
1489 ridx--;
1490 if(lidx-1 == pivot)
1491 {
1492 ridx++;
1493 pivot = ridx;
1494 }
1495 else if(ridx+1 == pivot)
1496 {
1497 lidx--;
1498 pivot = lidx;
1499 }
1500 }
1501 quicksortsad(arr, idx, left, pivot - 1);
1502 quicksortsad(arr, idx, pivot + 1, right);
1503 }
1504 }
1505
1506 //The improved MV prediction
1507 void vp8_mv_pred
1508 (
1509 VP8_COMP *cpi,
1510 MACROBLOCKD *xd,
1511 const MODE_INFO *here,
1512 MV *mvp,
1513 int refframe,
1514 int *ref_frame_sign_bias,
1515 int *sr,
1516 int near_sadidx[]
1517 )
1518 {
1519 const MODE_INFO *above = here - xd->mode_info_stride;
1520 const MODE_INFO *left = here - 1;
1521 const MODE_INFO *aboveleft = above - 1;
1522 int_mv near_mvs[8];
1523 int near_ref[8];
1524 int_mv mv;
1525 int vcnt=0;
1526 int find=0;
1527 int mb_offset;
1528
1529 int mvx[8];
1530 int mvy[8];
1531 int i;
1532
1533 mv.as_int = 0;
1534
1535 if(here->mbmi.ref_frame != INTRA_FRAME)
1536 {
1537 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;
1538 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;
1539
1540 // read in 3 nearby block's MVs from current frame as prediction candidates.
1541 if (above->mbmi.ref_frame != INTRA_FRAME)
1542 {
1543 near_mvs[vcnt].as_int = above->mbmi.mv.as_int;
1544 mv_bias(ref_frame_sign_bias[above->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1545 near_ref[vcnt] = above->mbmi.ref_frame;
1546 }
1547 vcnt++;
1548 if (left->mbmi.ref_frame != INTRA_FRAME)
1549 {
1550 near_mvs[vcnt].as_int = left->mbmi.mv.as_int;
1551 mv_bias(ref_frame_sign_bias[left->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1552 near_ref[vcnt] = left->mbmi.ref_frame;
1553 }
1554 vcnt++;
1555 if (aboveleft->mbmi.ref_frame != INTRA_FRAME)
1556 {
1557 near_mvs[vcnt].as_int = aboveleft->mbmi.mv.as_int;
1558 mv_bias(ref_frame_sign_bias[aboveleft->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1559 near_ref[vcnt] = aboveleft->mbmi.ref_frame;
1560 }
1561 vcnt++;
1562
1563 // read in 5 nearby block's MVs from last frame.
1564 if(cpi->common.last_frame_type != KEY_FRAME)
1565 {
1566 mb_offset = (-xd->mb_to_top_edge/128 + 1) * (xd->mode_info_stride +1) + (-xd->mb_to_left_edge/128 +1) ;
1567
1568 // current in last frame
1569 if (cpi->lf_ref_frame[mb_offset] != INTRA_FRAME)
1570 {
1571 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset].as_int;
1572 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1573 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset];
1574 }
1575 vcnt++;
1576
1577 // above in last frame
1578 if (cpi->lf_ref_frame[mb_offset - xd->mode_info_stride-1] != INTRA_FRAME)
1579 {
1580 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset - xd->mode_info_stride-1].as_int;
1581 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset - xd->mode_info_stride-1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1582 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset - xd->mode_info_stride-1];
1583 }
1584 vcnt++;
1585
1586 // left in last frame
1587 if (cpi->lf_ref_frame[mb_offset-1] != INTRA_FRAME)
1588 {
1589 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset -1].as_int;
1590 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset -1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1591 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset - 1];
1592 }
1593 vcnt++;
1594
1595 // right in last frame
1596 if (cpi->lf_ref_frame[mb_offset +1] != INTRA_FRAME)
1597 {
1598 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset +1].as_int;
1599 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset +1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1600 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset +1];
1601 }
1602 vcnt++;
1603
1604 // below in last frame
1605 if (cpi->lf_ref_frame[mb_offset + xd->mode_info_stride +1] != INTRA_FRAME)
1606 {
1607 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset + xd->mode_info_stride +1].as_int;
1608 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset + xd->mode_info_stride +1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1609 near_ref[vcnt] = cpi->lf_ref_frame[mb_offset + xd->mode_info_stride +1];
1610 }
1611 vcnt++;
1612 }
1613
1614 for(i=0; i< vcnt; i++)
1615 {
1616 if(near_ref[near_sadidx[i]] != INTRA_FRAME)
1617 {
1618 if(here->mbmi.ref_frame == near_ref[near_sadidx[i]])
1619 {
1620 mv.as_int = near_mvs[near_sadidx[i]].as_int;
1621 find = 1;
1622 if (i < 3)
1623 *sr = 3;
1624 else
1625 *sr = 2;
1626 break;
1627 }
1628 }
1629 }
1630
1631 if(!find)
1632 {
1633 for(i=0; i<vcnt; i++)
1634 {
1635 mvx[i] = near_mvs[i].as_mv.row;
1636 mvy[i] = near_mvs[i].as_mv.col;
1637 }
1638
1639 quicksortmv (mvx, 0, vcnt-1);
1640 quicksortmv (mvy, 0, vcnt-1);
1641 mv.as_mv.row = mvx[vcnt/2];
1642 mv.as_mv.col = mvy[vcnt/2];
1643
1644 find = 1;
1645 //sr is set to 0 to allow calling function to decide the search range.
1646 *sr = 0;
1647 }
1648 }
1649
1650 /* Set up return values */
1651 *mvp = mv.as_mv;
1652 vp8_clamp_mv(mvp, xd);
1653 }
1654
1655 void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[])
1656 {
1657
1658 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
1659
1660 //calculate sad for current frame 3 nearby MBs.
1661 if( xd->mb_to_top_edge==0 && xd->mb_to_left_edge ==0)
1662 {
1663 near_sad[0] = near_sad[1] = near_sad[2] = INT_MAX;
1664 }else if(xd->mb_to_top_edge==0)
1665 { //only has left MB for sad calculation.
1666 near_sad[0] = near_sad[2] = INT_MAX;
1667 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);
1668 }else if(xd->mb_to_left_edge ==0)
1669 { //only has left MB for sad calculation.
1670 near_sad[1] = near_sad[2] = INT_MAX;
1671 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);
1672 }else
1673 {
1674 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);
1675 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);
1676 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);
1677 }
1678
1679 if(cpi->common.last_frame_type != KEY_FRAME)
1680 {
1681 //calculate sad for last frame 5 nearby MBs.
1682 unsigned char *pre_y_buffer = cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_buffer + recon_yoffset;
1683 int pre_y_stride = cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_stride;
1684
1685 if(xd->mb_to_top_edge==0) near_sad[4] = INT_MAX;
1686 if(xd->mb_to_left_edge ==0) near_sad[5] = INT_MAX;
1687 if(xd->mb_to_right_edge ==0) near_sad[6] = INT_MAX;
1688 if(xd->mb_to_bottom_edge==0) near_sad[7] = INT_MAX;
1689
1690 if(near_sad[4] != INT_MAX)
1691 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);
1692 if(near_sad[5] != INT_MAX)
1693 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);
1694 near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer, pre_y_stride, 0x7fffffff);
1695 if(near_sad[6] != INT_MAX)
1696 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);
1697 if(near_sad[7] != INT_MAX)
1698 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);
1699 }
1700
1701 if(cpi->common.last_frame_type != KEY_FRAME)
1702 {
1703 quicksortsad(near_sad, near_sadidx, 0, 7);
1704 }else
1705 {
1706 quicksortsad(near_sad, near_sadidx, 0, 2);
1707 }
1708 }
1709
1710 #if !(CONFIG_REALTIME_ONLY)
1711 int vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int recon_uvoffset, int *returnrate, int *returndistortion, int *returnintra)
1712 {
1713 BLOCK *b = &x->block[0];
1714 BLOCKD *d = &x->e_mbd.block[0];
1715 MACROBLOCKD *xd = &x->e_mbd;
1716 B_MODE_INFO best_bmodes[16];
1717 MB_MODE_INFO best_mbmode;
1718 PARTITION_INFO best_partition;
1719 MV best_ref_mv;
1720 MV mode_mv[MB_MODE_COUNT];
1721 MB_PREDICTION_MODE this_mode;
1722 int num00;
1723 int best_mode_index = 0;
1724
1725 int i;
1726 int mode_index;
1727 int mdcounts[4];
1728 int rate;
1729 int distortion;
1730 int best_rd = INT_MAX; // 1 << 30;
1731 int ref_frame_cost[MAX_REF_FRAMES];
1732 int rate2, distortion2;
1733 int uv_intra_rate, uv_intra_distortion, uv_intra_rate_tokenonly;
1734 int rate_y, UNINITIALIZED_IS_SAFE(rate_uv);
1735 int distortion_uv;
1736 int best_yrd = INT_MAX;
1737
1738 //int all_rds[MAX_MODES]; // Experimental debug code.
1739 //int all_rates[MAX_MODES];
1740 //int all_dist[MAX_MODES];
1741 //int intermodecost[MAX_MODES];
1742
1743 MB_PREDICTION_MODE uv_intra_mode;
1744
1745 int force_no_skip = 0;
1746
1747 MV mvp;
1748 int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
1749 int saddone=0;
1750 int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7)
1751
1752 MV frame_nearest_mv[4];
1753 MV frame_near_mv[4];
1754 MV frame_best_ref_mv[4];
1755 int frame_mdcounts[4][4];
1756 int frame_lf_or_gf[4];
1757 unsigned char *y_buffer[4];
1758 unsigned char *u_buffer[4];
1759 unsigned char *v_buffer[4];
1760
1761 vpx_memset(&best_mbmode, 0, sizeof(best_mbmode));
1762
1763 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1764 {
1765 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
1766
1767 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[LAST_FRAME], &frame_near_mv[LAST_FRAME],
1768 &frame_best_ref_mv[LAST_FRAME], frame_mdcounts[LAST_FRAME], LAST_FRAME, cpi->common.ref_frame_sign_bias);
1769
1770 y_buffer[LAST_FRAME] = lst_yv12->y_buffer + recon_yoffset;
1771 u_buffer[LAST_FRAME] = lst_yv12->u_buffer + recon_uvoffset;
1772 v_buffer[LAST_FRAME] = lst_yv12->v_buffer + recon_uvoffset;
1773
1774 frame_lf_or_gf[LAST_FRAME] = 0;
1775 }
1776
1777 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1778 {
1779 YV12_BUFFER_CONFIG *gld_yv12 = &cpi->common.yv12_fb[cpi->common.gld_fb_idx];
1780
1781 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[GOLDEN_FRAME], &frame_near_mv[GOLDEN_FRAME],
1782 &frame_best_ref_mv[GOLDEN_FRAME], frame_mdcounts[GOLDEN_FRAME], GOLDEN_FRAME, cpi->common.ref_frame_sign_bias);
1783
1784 y_buffer[GOLDEN_FRAME] = gld_yv12->y_buffer + recon_yoffset;
1785 u_buffer[GOLDEN_FRAME] = gld_yv12->u_buffer + recon_uvoffset;
1786 v_buffer[GOLDEN_FRAME] = gld_yv12->v_buffer + recon_uvoffset;
1787
1788 frame_lf_or_gf[GOLDEN_FRAME] = 1;
1789 }
1790
1791 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1792 {
1793 YV12_BUFFER_CONFIG *alt_yv12 = &cpi->common.yv12_fb[cpi->common.alt_fb_idx];
1794
1795 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[ALTREF_FRAME], &frame_near_mv[ALTREF_FRAME],
1796 &frame_best_ref_mv[ALTREF_FRAME], frame_mdcounts[ALTREF_FRAME], ALTREF_FRAME, cpi->common.ref_frame_sign_bias);
1797
1798 y_buffer[ALTREF_FRAME] = alt_yv12->y_buffer + recon_yoffset;
1799 u_buffer[ALTREF_FRAME] = alt_yv12->u_buffer + recon_uvoffset;
1800 v_buffer[ALTREF_FRAME] = alt_yv12->v_buffer + recon_uvoffset;
1801
1802 frame_lf_or_gf[ALTREF_FRAME] = 1;
1803 }
1804
1805 *returnintra = INT_MAX;
1806 cpi->mbs_tested_so_far++; // Count of the number of MBs tested so far this frame
1807
1808 x->skip = 0;
1809
1810 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(cpi->prob_intra_coded);
1811
1812 // Special case treatment when GF and ARF are not sensible options for reference
1813 if (cpi->ref_frame_flags == VP8_LAST_FLAG)
1814 {
1815 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1816 + vp8_cost_zero(255);
1817 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1818 + vp8_cost_one(255)
1819 + vp8_cost_zero(128);
1820 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1821 + vp8_cost_one(255)
1822 + vp8_cost_one(128);
1823 }
1824 else
1825 {
1826 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1827 + vp8_cost_zero(cpi->prob_last_coded);
1828 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1829 + vp8_cost_one(cpi->prob_last_coded)
1830 + vp8_cost_zero(cpi->prob_gf_coded);
1831 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1832 + vp8_cost_one(cpi->prob_last_coded)
1833 + vp8_cost_one(cpi->prob_gf_coded);
1834 }
1835
1836 vpx_memset(mode_mv, 0, sizeof(mode_mv));
1837
1838 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1839 vp8_rd_pick_intra_mbuv_mode(cpi, x, &uv_intra_rate, &uv_intra_rate_tokenonly, &uv_intra_distortion);
1840 uv_intra_mode = x->e_mbd.mode_info_context->mbmi.uv_mode;
1841
1842 for (mode_index = 0; mode_index < MAX_MODES; mode_index++)
1843 {
1844 int this_rd = INT_MAX;
1845 int lf_or_gf = 0; // Lat Frame (01) or gf/arf (1)
1846 int disable_skip = 0;
1847 int other_cost = 0;
1848
1849 force_no_skip = 0;
1850
1851 // Experimental debug code.
1852 // Record of rd values recorded for this MB. -1 indicates not measured
1853 //all_rds[mode_index] = -1;
1854 //all_rates[mode_index] = -1;
1855 //all_dist[mode_index] = -1;
1856 //intermodecost[mode_index] = -1;
1857
1858 // Test best rd so far against threshold for trying this mode.
1859 if (best_rd <= cpi->rd_threshes[mode_index])
1860 continue;
1861
1862 // These variables hold are rolling total cost and distortion for this mode
1863 rate2 = 0;
1864 distortion2 = 0;
1865
1866 this_mode = vp8_mode_order[mode_index];
1867
1868 x->e_mbd.mode_info_context->mbmi.mode = this_mode;
1869 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1870 x->e_mbd.mode_info_context->mbmi.ref_frame = vp8_ref_frame_order[mode_index];
1871
1872 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
1873 // unless ARNR filtering is enabled in which case we want
1874 // an unfiltered alternative
1875 if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
1876 {
1877 if (this_mode != ZEROMV || x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
1878 continue;
1879 }
1880
1881 /* everything but intra */
1882 if (x->e_mbd.mode_info_context->mbmi.ref_frame)
1883 {
1884 x->e_mbd.pre.y_buffer = y_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1885 x->e_mbd.pre.u_buffer = u_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1886 x->e_mbd.pre.v_buffer = v_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1887 mode_mv[NEARESTMV] = frame_nearest_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1888 mode_mv[NEARMV] = frame_near_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1889 best_ref_mv = frame_best_ref_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1890 vpx_memcpy(mdcounts, frame_mdcounts[x->e_mbd.mode_info_context->mbmi.ref_frame], sizeof(mdcounts));
1891 lf_or_gf = frame_lf_or_gf[x->e_mbd.mode_info_context->mbmi.ref_frame];
1892 }
1893
1894 if(x->e_mbd.mode_info_context->mbmi.mode == NEWMV)
1895 {
1896 if(!saddone)
1897 {
1898 vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] );
1899 saddone = 1;
1900 }
1901
1902 vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, &mvp,
1903 x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
1904
1905 /* adjust mvp to make sure it is within MV range */
1906 if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL)
1907 mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL;
1908 else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL)
1909 mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL;
1910 if(mvp.col > best_ref_mv.col + MAX_FULL_PEL_VAL)
1911 mvp.col = best_ref_mv.col + MAX_FULL_PEL_VAL;
1912 else if(mvp.col < best_ref_mv.col - MAX_FULL_PEL_VAL)
1913 mvp.col = best_ref_mv.col - MAX_FULL_PEL_VAL;
1914 }
1915
1916 // Check to see if the testing frequency for this mode is at its max
1917 // If so then prevent it from being tested and increase the threshold for its testing
1918 if (cpi->mode_test_hit_counts[mode_index] && (cpi->mode_check_freq[mode_index] > 1))
1919 {
1920 if (cpi->mbs_tested_so_far <= cpi->mode_check_freq[mode_index] * cpi->mode_test_hit_counts[mode_index])
1921 {
1922 // Increase the threshold for coding this mode to make it less likely to be chosen
1923 cpi->rd_thresh_mult[mode_index] += 4;
1924
1925 if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
1926 cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1927
1928 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
1929
1930 continue;
1931 }
1932 }
1933
1934 // 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
1935 cpi->mode_test_hit_counts[mode_index] ++;
1936
1937 // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1938 if (cpi->zbin_mode_boost_enabled)
1939 {
1940 if ( vp8_ref_frame_order[mode_index] == INTRA_FRAME )
1941 cpi->zbin_mode_boost = 0;
1942 else
1943 {
1944 if (vp8_mode_order[mode_index] == ZEROMV)
1945 {
1946 if (vp8_ref_frame_order[mode_index] != LAST_FRAME)
1947 cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1948 else
1949 cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
1950 }
1951 else if (vp8_ref_frame_order[mode_index] == SPLITMV)
1952 cpi->zbin_mode_boost = 0;
1953 else
1954 cpi->zbin_mode_boost = MV_ZBIN_BOOST;
1955 }
1956
1957 vp8_update_zbin_extra(cpi, x);
1958 }
1959
1960 switch (this_mode)
1961 {
1962 case B_PRED:
1963 // Note the rate value returned here includes the cost of coding the BPRED mode : x->mbmode_cost[x->e_mbd.frame_type][BPRED];
1964 vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate, &rate_y, &distortion);
1965 rate2 += rate;
1966 distortion2 += distortion;
1967 rate2 += uv_intra_rate;
1968 rate_uv = uv_intra_rate_tokenonly;
1969 distortion2 += uv_intra_distortion;
1970 distortion_uv = uv_intra_distortion;
1971 break;
1972
1973 case SPLITMV:
1974 {
1975 int tmp_rd;
1976 int this_rd_thresh;
1977
1978 this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME) ? cpi->rd_threshes[THR_NEWMV] : cpi->rd_threshes[THR_NEWA];
1979 this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == GOLDEN_FRAME) ? cpi->rd_threshes[THR_NEWG]: this_rd_thresh;
1980
1981 tmp_rd = vp8_rd_pick_best_mbsegmentation(cpi, x, &best_ref_mv,
1982 best_yrd, mdcounts,
1983 &rate, &rate_y, &distortion, this_rd_thresh) ;
1984
1985 rate2 += rate;
1986 distortion2 += distortion;
1987
1988 // If even the 'Y' rd value of split is higher than best so far then dont bother looking at UV
1989 if (tmp_rd < best_yrd)
1990 {
1991 // Now work out UV cost and add it in
1992 vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
1993 rate2 += rate_uv;
1994 distortion2 += distortion_uv;
1995 }
1996 else
1997 {
1998 this_rd = INT_MAX;
1999 disable_skip = 1;
2000 }
2001 }
2002 break;
2003 case DC_PRED:
2004 case V_PRED:
2005 case H_PRED:
2006 case TM_PRED:
2007 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
2008 vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
2009 macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb)) ;
2010 rate2 += rate_y;
2011 distortion2 += distortion;
2012 rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
2013 rate2 += uv_intra_rate;
2014 rate_uv = uv_intra_rate_tokenonly;
2015 distortion2 += uv_intra_distortion;
2016 distortion_uv = uv_intra_distortion;
2017 break;
2018
2019 case NEWMV:
2020
2021 // Decrement full search counter
2022 if (cpi->check_freq[lf_or_gf] > 0)
2023 cpi->check_freq[lf_or_gf] --;
2024
2025 {
2026 int thissme;
2027 int bestsme = INT_MAX;
2028 int step_param = cpi->sf.first_step;
2029 int search_range;
2030 int further_steps;
2031 int n;
2032
2033 int col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3;
2034 int col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3;
2035 int row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3;
2036 int row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3;
2037
2038 int tmp_col_min = x->mv_col_min;
2039 int tmp_col_max = x->mv_col_max;
2040 int tmp_row_min = x->mv_row_min;
2041 int tmp_row_max = x->mv_row_max;
2042
2043 // Get intersection of UMV window and valid MV window to reduce # of checks in diamond search.
2044 if (x->mv_col_min < col_min )
2045 x->mv_col_min = col_min;
2046 if (x->mv_col_max > col_max )
2047 x->mv_col_max = col_max;
2048 if (x->mv_row_min < row_min )
2049 x->mv_row_min = row_min;
2050 if (x->mv_row_max > row_max )
2051 x->mv_row_max = row_max;
2052
2053 //adjust search range according to sr from mv prediction
2054 if(sr > step_param)
2055 step_param = sr;
2056
2057 // Work out how long a search we should do
2058 search_range = MAXF(abs(best_ref_mv.col), abs(best_ref_mv.row)) >> 3;
2059
2060 if (search_range >= x->vector_range)
2061 x->vector_range = search_range;
2062 else if (x->vector_range > cpi->sf.min_fs_radius)
2063 x->vector_range--;
2064
2065 // Initial step/diamond search
2066 {
2067 int sadpb = x->sadperbit16;
2068
2069 if (cpi->sf.search_method == HEX)
2070 {
2071 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);
2072 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2073 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2074 }
2075 else
2076 {
2077 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
2078 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2079 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2080
2081 // Further step/diamond searches as necessary
2082 n = 0;
2083 further_steps = (cpi->sf.max_step_search_steps - 1) - step_param;
2084
2085 n = num00;
2086 num00 = 0;
2087
2088 while (n < further_steps)
2089 {
2090 n++;
2091
2092 if (num00)
2093 num00--;
2094 else
2095 {
2096 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
2097
2098 if (thissme < bestsme)
2099 {
2100 bestsme = thissme;
2101 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2102 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2103 }
2104 else
2105 {
2106 d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2107 d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2108 }
2109 }
2110 }
2111 }
2112
2113 }
2114
2115 // Should we do a full search
2116 if (!cpi->check_freq[lf_or_gf] || cpi->do_full[lf_or_gf])
2117 {
2118 int thissme;
2119 int full_flag_thresh = 0;
2120 MV full_mvp;
2121
2122 full_mvp.row = d->bmi.mv.as_mv.row <<3; // use diamond search result as full search staring point
2123 full_mvp.col = d->bmi.mv.as_mv.col <<3;
2124
2125 // Update x->vector_range based on best vector found in step search
2126 search_range = MAXF(abs((mvp.row>>3) - d->bmi.mv.as_mv.row), abs((mvp.col>>3) - d->bmi.mv.as_mv.col));
2127 //search_range *= 1.4; //didn't improve PSNR
2128
2129 if (search_range > x->vector_range)
2130 x->vector_range = search_range;
2131 else
2132 search_range = x->vector_range;
2133
2134 // Apply limits
2135 search_range = (search_range > cpi->sf.max_fs_radius) ? cpi->sf.max_fs_radius : search_range;
2136
2137 //add this to reduce full search range.
2138 if(sr<=3 && search_range > 8) search_range = 8;
2139
2140 {
2141 int sadpb = x->sadperbit16 >> 2;
2142 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);
2143 }
2144
2145 // Barrier threshold to initiating full search
2146 // full_flag_thresh = 10 + (thissme >> 7);
2147 if ((thissme + full_flag_thresh) < bestsme)
2148 {
2149 cpi->do_full[lf_or_gf] ++;
2150 bestsme = thissme;
2151 }
2152 else if (thissme < bestsme)
2153 bestsme = thissme;
2154 else
2155 {
2156 cpi->do_full[lf_or_gf] = cpi->do_full[lf_or_gf] >> 1;
2157 cpi->check_freq[lf_or_gf] = cpi->sf.full_freq[lf_or_gf];
2158
2159 // The full search result is actually worse so re-instate the previous best vector
2160 d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2161 d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2162 }
2163 }
2164
2165 x->mv_col_min = tmp_col_min;
2166 x->mv_col_max = tmp_col_max;
2167 x->mv_row_min = tmp_row_min;
2168 x->mv_row_max = tmp_row_max;
2169
2170 if (bestsme < INT_MAX)
2171 // 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
2172 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);
2173
2174 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2175 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2176
2177 // Add the new motion vector cost to our rolling cost variable
2178 rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96);
2179
2180 }
2181
2182 case NEARESTMV:
2183 case NEARMV:
2184
2185 // Clip "next_nearest" so that it does not extend to far out of image
2186 if (mode_mv[this_mode].col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
2187 mode_mv[this_mode].col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
2188 else if (mode_mv[this_mode].col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
2189 mode_mv[this_mode].col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
2190
2191 if (mode_mv[this_mode].row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
2192 mode_mv[this_mode].row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
2193 else if (mode_mv[this_mode].row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
2194 mode_mv[this_mode].row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
2195
2196 // 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.
2197 if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) &&
2198 ((mode_mv[this_mode].row == 0) && (mode_mv[this_mode].col == 0)))
2199 continue;
2200
2201 case ZEROMV:
2202
2203 mv_selected:
2204
2205 // Trap vectors that reach beyond the UMV borders
2206 // Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point
2207 // because of the lack of break statements in the previous two cases.
2208 if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) ||
2209 ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max))
2210 continue;
2211
2212 vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);
2213 vp8_build_inter_predictors_mby(&x->e_mbd);
2214
2215 if (cpi->active_map_enabled && x->active_ptr[0] == 0) {
2216 x->skip = 1;
2217 }
2218 else if (x->encode_breakout)
2219 {
2220 int sum, sse;
2221 int threshold = (xd->block[0].dequant[1]
2222 * xd->block[0].dequant[1] >>4);
2223
2224 if(threshold < x->encode_breakout)
2225 threshold = x->encode_breakout;
2226
2227 VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16var)
2228 (x->src.y_buffer, x->src.y_stride,
2229 x->e_mbd.predictor, 16, (unsigned int *)(&sse), &sum);
2230
2231 if (sse < threshold)
2232 {
2233 // Check u and v to make sure skip is ok
2234 int sse2 = 0;
2235 /* If theres is no codeable 2nd order dc
2236 or a very small uniform pixel change change */
2237 if (abs(sum) < (xd->block[24].dequant[0]<<2)||
2238 ((sum * sum>>8) > sse && abs(sum) <128))
2239 {
2240 sse2 = VP8_UVSSE(x, IF_RTCD(&cpi->rtcd.variance));
2241
2242 if (sse2 * 2 < threshold)
2243 {
2244 x->skip = 1;
2245 distortion2 = sse + sse2;
2246 rate2 = 500;
2247
2248 /* for best_yrd calculation */
2249 rate_uv = 0;
2250 distortion_uv = sse2;
2251
2252 disable_skip = 1;
2253 this_rd = RDCOST(x->rdmult, x->rddiv, rate2,
2254 distortion2);
2255
2256 break;
2257 }
2258 }
2259 }
2260 }
2261
2262
2263 //intermodecost[mode_index] = vp8_cost_mv_ref(this_mode, mdcounts); // Experimental debug code
2264
2265 // Add in the Mv/mode cost
2266 rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
2267
2268 // Y cost and distortion
2269 macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
2270 rate2 += rate_y;
2271 distortion2 += distortion;
2272
2273 // UV cost and distortion
2274 vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
2275 rate2 += rate_uv;
2276 distortion2 += distortion_uv;
2277 break;
2278
2279 default:
2280 break;
2281 }
2282
2283 // Where skip is allowable add in the default per mb cost for the no skip case.
2284 // where we then decide to skip we have to delete this and replace it with the
2285 // cost of signallying a skip
2286 if (cpi->common.mb_no_coeff_skip)
2287 {
2288 other_cost += vp8_cost_bit(cpi->prob_skip_false, 0);
2289 rate2 += other_cost;
2290 }
2291
2292 // Estimate the reference frame signaling cost and add it to the rolling cost variable.
2293 rate2 += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2294
2295 if (!disable_skip)
2296 {
2297 // Test for the condition where skip block will be activated because there are no non zero coefficients and make any necessary adjustment for rate
2298 if (cpi->common.mb_no_coeff_skip)
2299 {
2300 int tteob;
2301
2302 tteob = 0;
2303
2304 for (i = 0; i <= 24; i++)
2305 {
2306 tteob += x->e_mbd.block[i].eob;
2307 }
2308
2309 if (tteob == 0)
2310 {
2311 rate2 -= (rate_y + rate_uv);
2312 //for best_yrd calculation
2313 rate_uv = 0;
2314
2315 // Back out no skip flag costing and add in skip flag costing
2316 if (cpi->prob_skip_false)
2317 {
2318 int prob_skip_cost;
2319
2320 prob_skip_cost = vp8_cost_bit(cpi->prob_skip_false, 1);
2321 prob_skip_cost -= vp8_cost_bit(cpi->prob_skip_false, 0);
2322 rate2 += prob_skip_cost;
2323 other_cost += prob_skip_cost;
2324 }
2325 }
2326 }
2327 // Calculate the final RD estimate for this mode
2328 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
2329 }
2330
2331 // Experimental debug code.
2332 //all_rds[mode_index] = this_rd;
2333 //all_rates[mode_index] = rate2;
2334 //all_dist[mode_index] = distortion2;
2335
2336 if ((x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) && (this_rd < *returnintra))
2337 {
2338 *returnintra = this_rd ;
2339 }
2340
2341 // Did this mode help.. i.i is it the new best mode
2342 if (this_rd < best_rd || x->skip)
2343 {
2344 // Note index of best mode so far
2345 best_mode_index = mode_index;
2346 x->e_mbd.mode_info_context->mbmi.force_no_skip = force_no_skip;
2347
2348 if (this_mode <= B_PRED)
2349 {
2350 x->e_mbd.mode_info_context->mbmi.uv_mode = uv_intra_mode;
2351 }
2352
2353 other_cost += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2354
2355 /* Calculate the final y RD estimate for this mode */
2356 best_yrd = RDCOST(x->rdmult, x->rddiv, (rate2-rate_uv-other_cost),
2357 (distortion2-distortion_uv));
2358
2359 *returnrate = rate2;
2360 *returndistortion = distortion2;
2361 best_rd = this_rd;
2362 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, sizeof(MB_MODE_INFO));
2363 vpx_memcpy(&best_partition, x->partition_info, sizeof(PARTITION_INFO));
2364
2365 for (i = 0; i < 16; i++)
2366 {
2367 vpx_memcpy(&best_bmodes[i], &x->e_mbd.block[i].bmi, sizeof(B_MODE_INFO));
2368 }
2369
2370 // Testing this mode gave rise to an improvement in best error score. Lower threshold a bit for next time
2371 cpi->rd_thresh_mult[mode_index] = (cpi->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ? cpi->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT;
2372 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2373 }
2374
2375 // If the mode did not help improve the best error case then raise the threshold for testing that mode next time around.
2376 else
2377 {
2378 cpi->rd_thresh_mult[mode_index] += 4;
2379
2380 if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
2381 cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
2382
2383 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2384 }
2385
2386 if (x->skip)
2387 break;
2388
2389 }
2390
2391 // Reduce the activation RD thresholds for the best choice mode
2392 if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2)))
2393 {
2394 int best_adjustment = (cpi->rd_thresh_mult[best_mode_index] >> 2);
2395
2396 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;
2397 cpi->rd_threshes[best_mode_index] = (cpi->rd_baseline_thresh[best_mode_index] >> 7) * cpi->rd_thresh_mult[best_mode_index];
2398
2399 // If we chose a split mode then reset the new MV thresholds as well
2400 /*if ( vp8_mode_order[best_mode_index] == SPLITMV )
2401 {
2402 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWMV] >> 4);
2403 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;
2404 cpi->rd_threshes[THR_NEWMV] = (cpi->rd_baseline_thresh[THR_NEWMV] >> 7) * cpi->rd_thresh_mult[THR_NEWMV];
2405
2406 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWG] >> 4);
2407 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;
2408 cpi->rd_threshes[THR_NEWG] = (cpi->rd_baseline_thresh[THR_NEWG] >> 7) * cpi->rd_thresh_mult[THR_NEWG];
2409
2410 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWA] >> 4);
2411 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;
2412 cpi->rd_threshes[THR_NEWA] = (cpi->rd_baseline_thresh[THR_NEWA] >> 7) * cpi->rd_thresh_mult[THR_NEWA];
2413 }*/
2414
2415 }
2416
2417 // If we have chosen new mv or split then decay the full search check count more quickly.
2418 if ((vp8_mode_order[best_mode_index] == NEWMV) || (vp8_mode_order[best_mode_index] == SPLITMV))
2419 {
2420 int lf_or_gf = (vp8_ref_frame_order[best_mode_index] == LAST_FRAME) ? 0 : 1;
2421
2422 if (cpi->check_freq[lf_or_gf] && !cpi->do_full[lf_or_gf])
2423 {
2424 cpi->check_freq[lf_or_gf] --;
2425 }
2426 }
2427
2428 // Keep a record of best mode index that we chose
2429 cpi->last_best_mode_index = best_mode_index;
2430
2431 // Note how often each mode chosen as best
2432 cpi->mode_chosen_counts[best_mode_index] ++;
2433
2434
2435 if (cpi->is_src_frame_alt_ref && (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME))
2436 {
2437 best_mbmode.mode = ZEROMV;
2438 best_mbmode.ref_frame = ALTREF_FRAME;
2439 best_mbmode.mv.as_int = 0;
2440 best_mbmode.uv_mode = 0;
2441 best_mbmode.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
2442 best_mbmode.partitioning = 0;
2443 best_mbmode.dc_diff = 0;
2444
2445 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2446 vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2447
2448 for (i = 0; i < 16; i++)
2449 {
2450 vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
2451 }
2452
2453 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2454
2455 return best_rd;
2456 }
2457
2458
2459 if(best_mbmode.mode <= B_PRED)
2460 {
2461 int i;
2462 for (i = 0; i < 16; i++)
2463 {
2464 best_bmodes[i].mv.as_int = 0;
2465 }
2466 }
2467
2468 // macroblock modes
2469 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2470 vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2471
2472 for (i = 0; i < 16; i++)
2473 {
2474 vpx_memcpy(&x->e_mbd.block[i].bmi, &best_bmodes[i], sizeof(B_MODE_INFO));
2475 }
2476
2477 x->e_mbd.mode_info_context->mbmi.mv.as_mv = x->e_mbd.block[15].bmi.mv.as_mv;
2478
2479 return best_rd;
2480 }
2481 #endif
mirror for libvpx