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