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