2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
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.
16 #include "vp8/common/pragmas.h"
19 #include "treewriter.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"
30 #include "vp8/common/idct.h"
31 #include "vp8/common/g_common.h"
35 #include "vpx_mem/vpx_mem.h"
37 #include "vp8/common/systemdependent.h"
39 #if CONFIG_RUNTIME_CPU_DETECT
40 #define IF_RTCD(x) (x)
42 #define IF_RTCD(x) NULL
46 extern void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x);
47 extern void vp8_update_zbin_extra(VP8_COMP *cpi, MACROBLOCK *x);
49 #define MAXF(a,b) (((a) > (b)) ? (a) : (b))
51 static const int auto_speed_thresh[17] =
72 const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES] =
104 const MV_REFERENCE_FRAME vp8_ref_frame_order[MAX_MODES] =
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]
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++)
148 vp8_cost_tokens((int *)(c [i][j][k]), p [i][j][k], vp8_coef_tree);
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,
159 /* values are now correlated to quantizer */
160 static int sad_per_bit16lut[QINDEX_RANGE] =
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
179 static int sad_per_bit4lut[QINDEX_RANGE] =
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,
199 void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex)
201 cpi->mb.sadperbit16 = sad_per_bit16lut[QIndex];
202 cpi->mb.sadperbit4 = sad_per_bit4lut[QIndex];
205 void vp8_initialize_rd_consts(VP8_COMP *cpi, int Qvalue)
209 double capped_q = (Qvalue < 160) ? (double)Qvalue : 160.0;
210 double rdconst = 3.00;
212 vp8_clear_system_state(); //__asm emms;
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));
220 // Extend rate multiplier along side quantizer zbin increases
221 if (cpi->zbin_over_quant > 0)
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));
233 if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME))
235 if (cpi->next_iiratio > 31)
236 cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
238 cpi->RDMULT += (cpi->RDMULT * rd_iifactor[cpi->next_iiratio]) >> 4;
241 cpi->mb.errorperbit = (cpi->RDMULT / 100);
242 cpi->mb.errorperbit += (cpi->mb.errorperbit==0);
244 vp8_set_speed_features(cpi);
246 q = (int)pow(Qvalue, 1.25);
251 if (cpi->RDMULT > 1000)
256 for (i = 0; i < MAX_MODES; i++)
258 if (cpi->sf.thresh_mult[i] < INT_MAX)
260 cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q / 100;
264 cpi->rd_threshes[i] = INT_MAX;
267 cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
274 for (i = 0; i < MAX_MODES; i++)
276 if (cpi->sf.thresh_mult[i] < (INT_MAX / q))
278 cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q;
282 cpi->rd_threshes[i] = INT_MAX;
285 cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
291 (const vp8_prob( *)[8][3][11]) cpi->common.fc.coef_probs
294 vp8_init_mode_costs(cpi);
298 void vp8_auto_select_speed(VP8_COMP *cpi)
300 int used = cpi->oxcf.cpu_used;
302 int milliseconds_for_compress = (int)(1000000 / cpi->oxcf.frame_rate);
304 milliseconds_for_compress = milliseconds_for_compress * (16 - cpi->oxcf.cpu_used) / 16;
312 f = fopen("speed.stt", "a");
313 fprintf(f, " %8ld %10ld %10ld %10ld\n",
314 cpi->common.current_video_frame, cpi->Speed, milliseconds_for_compress, cpi->avg_pick_mode_time);
321 // this is done during parameter valid check
328 if (cpi->avg_pick_mode_time < milliseconds_for_compress && (cpi->avg_encode_time - cpi->avg_pick_mode_time) < milliseconds_for_compress)
330 if (cpi->avg_pick_mode_time == 0)
336 if (milliseconds_for_compress * 100 < cpi->avg_encode_time * 95)
339 cpi->avg_pick_mode_time = 0;
340 cpi->avg_encode_time = 0;
348 if (milliseconds_for_compress * 100 > cpi->avg_encode_time * auto_speed_thresh[cpi->Speed])
351 cpi->avg_pick_mode_time = 0;
352 cpi->avg_encode_time = 0;
354 // In real-time mode, cpi->speed is in [4, 16].
355 if (cpi->Speed < 4) //if ( cpi->Speed < 0 )
357 cpi->Speed = 4; //cpi->Speed = 0;
370 cpi->avg_pick_mode_time = 0;
371 cpi->avg_encode_time = 0;
375 int vp8_block_error_c(short *coeff, short *dqcoeff)
380 for (i = 0; i < 16; i++)
382 int this_diff = coeff[i] - dqcoeff[i];
383 error += this_diff * this_diff;
389 int vp8_mbblock_error_c(MACROBLOCK *mb, int dc)
394 int berror, error = 0;
396 for (i = 0; i < 16; i++)
399 bd = &mb->e_mbd.block[i];
403 for (j = dc; j < 16; j++)
405 int this_diff = be->coeff[j] - bd->dqcoeff[j];
406 berror += this_diff * this_diff;
415 int vp8_mbuverror_c(MACROBLOCK *mb)
425 for (i = 16; i < 24; i++)
428 bd = &mb->e_mbd.block[i];
430 error += vp8_block_error_c(be->coeff, bd->dqcoeff);
436 int VP8_UVSSE(MACROBLOCK *x, const vp8_variance_rtcd_vtable_t *rtcd)
438 unsigned char *uptr, *vptr;
439 unsigned char *upred_ptr = (*(x->block[16].base_src) + x->block[16].src);
440 unsigned char *vpred_ptr = (*(x->block[20].base_src) + x->block[20].src);
441 int uv_stride = x->block[16].src_stride;
443 unsigned int sse1 = 0;
444 unsigned int sse2 = 0;
448 int pre_stride = x->e_mbd.block[16].pre_stride;
450 vp8_build_uvmvs(&x->e_mbd, 0);
451 mv_row = x->e_mbd.block[16].bmi.mv.as_mv.row;
452 mv_col = x->e_mbd.block[16].bmi.mv.as_mv.col;
454 offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
455 uptr = x->e_mbd.pre.u_buffer + offset;
456 vptr = x->e_mbd.pre.v_buffer + offset;
458 if ((mv_row | mv_col) & 7)
460 VARIANCE_INVOKE(rtcd, subpixvar8x8)(uptr, pre_stride, mv_col & 7, mv_row & 7, upred_ptr, uv_stride, &sse2);
461 VARIANCE_INVOKE(rtcd, subpixvar8x8)(vptr, pre_stride, mv_col & 7, mv_row & 7, vpred_ptr, uv_stride, &sse1);
466 VARIANCE_INVOKE(rtcd, subpixvar8x8)(uptr, pre_stride, mv_col & 7, mv_row & 7, upred_ptr, uv_stride, &sse2);
467 VARIANCE_INVOKE(rtcd, subpixvar8x8)(vptr, pre_stride, mv_col & 7, mv_row & 7, vpred_ptr, uv_stride, &sse1);
475 static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type, ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l)
477 int c = !type; /* start at coef 0, unless Y with Y2 */
479 int pt ; /* surrounding block/prev coef predictor */
481 short *qcoeff_ptr = b->qcoeff;
483 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
485 # define QC( I) ( qcoeff_ptr [vp8_default_zig_zag1d[I]] )
490 int t = vp8_dct_value_tokens_ptr[v].Token;
491 cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [t];
492 cost += vp8_dct_value_cost_ptr[v];
493 pt = vp8_prev_token_class[t];
499 cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [DCT_EOB_TOKEN];
501 pt = (c != !type); // is eob first coefficient;
507 static int vp8_rdcost_mby(MACROBLOCK *mb)
511 MACROBLOCKD *x = &mb->e_mbd;
512 ENTROPY_CONTEXT_PLANES t_above, t_left;
516 vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
517 vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
519 ta = (ENTROPY_CONTEXT *)&t_above;
520 tl = (ENTROPY_CONTEXT *)&t_left;
522 for (b = 0; b < 16; b++)
523 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_NO_DC,
524 ta + vp8_block2above[b], tl + vp8_block2left[b]);
526 cost += cost_coeffs(mb, x->block + 24, PLANE_TYPE_Y2,
527 ta + vp8_block2above[24], tl + vp8_block2left[24]);
532 static void macro_block_yrd( MACROBLOCK *mb,
535 const vp8_encodemb_rtcd_vtable_t *rtcd)
538 MACROBLOCKD *const x = &mb->e_mbd;
539 BLOCK *const mb_y2 = mb->block + 24;
540 BLOCKD *const x_y2 = x->block + 24;
541 short *Y2DCPtr = mb_y2->src_diff;
545 ENCODEMB_INVOKE(rtcd, submby)( mb->src_diff, mb->src.y_buffer,
546 mb->e_mbd.predictor, mb->src.y_stride );
548 // Fdct and building the 2nd order block
549 for (beptr = mb->block; beptr < mb->block + 16; beptr += 2)
551 mb->vp8_short_fdct8x4(beptr->src_diff, beptr->coeff, 32);
552 *Y2DCPtr++ = beptr->coeff[0];
553 *Y2DCPtr++ = beptr->coeff[16];
557 mb->short_walsh4x4(mb_y2->src_diff, mb_y2->coeff, 8);
560 for (b = 0; b < 16; b++)
562 mb->quantize_b(&mb->block[b], &mb->e_mbd.block[b]);
565 // DC predication and Quantization of 2nd Order block
566 mb->quantize_b(mb_y2, x_y2);
569 d = ENCODEMB_INVOKE(rtcd, mberr)(mb, 1) << 2;
570 d += ENCODEMB_INVOKE(rtcd, berr)(mb_y2->coeff, x_y2->dqcoeff);
572 *Distortion = (d >> 4);
575 *Rate = vp8_rdcost_mby(mb);
578 static void copy_predictor(unsigned char *dst, const unsigned char *predictor)
580 const unsigned int *p = (const unsigned int *)predictor;
581 unsigned int *d = (unsigned int *)dst;
587 static int rd_pick_intra4x4block(
592 B_PREDICTION_MODE *best_mode,
593 unsigned int *bmode_costs,
601 B_PREDICTION_MODE mode;
602 int best_rd = INT_MAX;
606 ENTROPY_CONTEXT ta = *a, tempa = *a;
607 ENTROPY_CONTEXT tl = *l, templ = *l;
609 * The predictor buffer is a 2d buffer with a stride of 16. Create
610 * a temp buffer that meets the stride requirements, but we are only
611 * interested in the left 4x4 block
613 DECLARE_ALIGNED_ARRAY(16, unsigned char, best_predictor, 16*4);
614 DECLARE_ALIGNED_ARRAY(16, short, best_dqcoeff, 16);
616 for (mode = B_DC_PRED; mode <= B_HU_PRED; mode++)
621 rate = bmode_costs[mode];
623 vp8_predict_intra4x4(b, mode, b->predictor);
624 ENCODEMB_INVOKE(IF_RTCD(&cpi->rtcd.encodemb), subb)(be, b, 16);
625 x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
626 x->quantize_b(be, b);
631 ratey = cost_coeffs(x, b, PLANE_TYPE_Y_WITH_DC, &tempa, &templ);
633 distortion = ENCODEMB_INVOKE(IF_RTCD(&cpi->rtcd.encodemb), berr)(be->coeff, b->dqcoeff) >> 2;
635 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
637 if (this_rd < best_rd)
641 *bestdistortion = distortion;
646 copy_predictor(best_predictor, b->predictor);
647 vpx_memcpy(best_dqcoeff, b->dqcoeff, 32);
651 b->bmi.mode = (B_PREDICTION_MODE)(*best_mode);
653 IDCT_INVOKE(IF_RTCD(&cpi->rtcd.common->idct), idct16)(best_dqcoeff, b->diff, 32);
654 RECON_INVOKE(IF_RTCD(&cpi->rtcd.common->recon), recon)(best_predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
659 int vp8_rd_pick_intra4x4mby_modes(VP8_COMP *cpi, MACROBLOCK *mb, int *Rate,
660 int *rate_y, int *Distortion, int best_rd)
662 MACROBLOCKD *const xd = &mb->e_mbd;
664 int cost = mb->mbmode_cost [xd->frame_type] [B_PRED];
667 long long total_rd = 0;
668 ENTROPY_CONTEXT_PLANES t_above, t_left;
671 unsigned int *bmode_costs;
673 vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
674 vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
676 ta = (ENTROPY_CONTEXT *)&t_above;
677 tl = (ENTROPY_CONTEXT *)&t_left;
679 vp8_intra_prediction_down_copy(xd);
681 bmode_costs = mb->inter_bmode_costs;
683 for (i = 0; i < 16; i++)
685 MODE_INFO *const mic = xd->mode_info_context;
686 const int mis = xd->mode_info_stride;
687 B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
688 int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(ry), UNINITIALIZED_IS_SAFE(d);
690 if (mb->e_mbd.frame_type == KEY_FRAME)
692 const B_PREDICTION_MODE A = vp8_above_bmi(mic, i, mis)->mode;
693 const B_PREDICTION_MODE L = vp8_left_bmi(mic, i)->mode;
695 bmode_costs = mb->bmode_costs[A][L];
698 total_rd += rd_pick_intra4x4block(
699 cpi, mb, mb->block + i, xd->block + i, &best_mode, bmode_costs,
700 ta + vp8_block2above[i],
701 tl + vp8_block2left[i], &r, &ry, &d);
706 mic->bmi[i].mode = xd->block[i].bmi.mode = best_mode;
708 if(total_rd >= (long long)best_rd)
712 if(total_rd >= (long long)best_rd)
716 *rate_y += tot_rate_y;
717 *Distortion = distortion;
719 return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
721 int vp8_rd_pick_intra16x16mby_mode(VP8_COMP *cpi,
727 MB_PREDICTION_MODE mode;
728 MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
731 int best_rd = INT_MAX;
734 //Y Search for 16x16 intra prediction mode
735 for (mode = DC_PRED; mode <= TM_PRED; mode++)
737 x->e_mbd.mode_info_context->mbmi.mode = mode;
739 RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby)
742 macro_block_yrd(x, &ratey, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
743 rate = ratey + x->mbmode_cost[x->e_mbd.frame_type]
744 [x->e_mbd.mode_info_context->mbmi.mode];
746 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
748 if (this_rd < best_rd)
750 mode_selected = mode;
754 *Distortion = distortion;
758 x->e_mbd.mode_info_context->mbmi.mode = mode_selected;
762 static int rd_cost_mbuv(MACROBLOCK *mb)
766 MACROBLOCKD *x = &mb->e_mbd;
767 ENTROPY_CONTEXT_PLANES t_above, t_left;
771 vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
772 vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
774 ta = (ENTROPY_CONTEXT *)&t_above;
775 tl = (ENTROPY_CONTEXT *)&t_left;
777 for (b = 16; b < 24; b++)
778 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_UV,
779 ta + vp8_block2above[b], tl + vp8_block2left[b]);
785 static int vp8_rd_inter_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *distortion, int fullpixel)
787 vp8_build_uvmvs(&x->e_mbd, fullpixel);
788 vp8_encode_inter16x16uvrd(IF_RTCD(&cpi->rtcd), x);
791 *rate = rd_cost_mbuv(x);
792 *distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
794 return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
797 void vp8_rd_pick_intra_mbuv_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int *distortion)
799 MB_PREDICTION_MODE mode;
800 MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
801 int best_rd = INT_MAX;
802 int UNINITIALIZED_IS_SAFE(d), UNINITIALIZED_IS_SAFE(r);
805 for (mode = DC_PRED; mode <= TM_PRED; mode++)
811 x->e_mbd.mode_info_context->mbmi.uv_mode = mode;
812 vp8_build_intra_predictors_mbuv(&x->e_mbd);
813 ENCODEMB_INVOKE(IF_RTCD(&cpi->rtcd.encodemb), submbuv)(x->src_diff,
814 x->src.u_buffer, x->src.v_buffer, x->e_mbd.predictor,
816 vp8_transform_mbuv(x);
817 vp8_quantize_mbuv(x);
819 rate_to = rd_cost_mbuv(x);
820 rate = rate_to + x->intra_uv_mode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.uv_mode];
822 distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
824 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
826 if (this_rd < best_rd)
831 *rate_tokenonly = rate_to;
832 mode_selected = mode;
839 x->e_mbd.mode_info_context->mbmi.uv_mode = mode_selected;
842 int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
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);
851 void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv)
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;
859 for (i = 0; i < 16; i++)
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;
868 static int labels2mode(
870 int const *labelings, int which_label,
871 B_PREDICTION_MODE this_mode,
872 MV *this_mv, MV *best_ref_mv,
876 MACROBLOCKD *const xd = & x->e_mbd;
877 MODE_INFO *const mic = xd->mode_info_context;
878 const int mis = xd->mode_info_stride;
883 /* We have to be careful retrieving previously-encoded motion vectors.
884 Ones from this macroblock have to be pulled from the BLOCKD array
885 as they have not yet made it to the bmi array in our MB_MODE_INFO. */
891 BLOCKD *const d = xd->block + i;
892 const int row = i >> 2, col = i & 3;
896 if (labelings[i] != which_label)
899 if (col && labelings[i] == labelings[i-1])
901 else if (row && labelings[i] == labelings[i-4])
905 // the only time we should do costing for new motion vector or mode
906 // is when we are on a new label (jbb May 08, 2007)
907 switch (m = this_mode)
910 thismvcost = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
913 *this_mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
916 *this_mv = row ? d[-4].bmi.mv.as_mv : vp8_above_bmi(mic, i, mis)->mv.as_mv;
919 this_mv->row = this_mv->col = 0;
925 if (m == ABOVE4X4) // replace above with left if same
927 const MV mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
929 if (mv.row == this_mv->row && mv.col == this_mv->col)
933 cost = x->inter_bmode_costs[ m];
937 d->bmi.mv.as_mv = *this_mv;
946 static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels,
947 int which_label, ENTROPY_CONTEXT *ta,
952 MACROBLOCKD *x = &mb->e_mbd;
954 for (b = 0; b < 16; b++)
955 if (labels[ b] == which_label)
956 cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_WITH_DC,
957 ta + vp8_block2above[b],
958 tl + vp8_block2left[b]);
963 static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, int const *labels, int which_label, const vp8_encodemb_rtcd_vtable_t *rtcd)
966 unsigned int distortion = 0;
968 for (i = 0; i < 16; i++)
970 if (labels[i] == which_label)
972 BLOCKD *bd = &x->e_mbd.block[i];
973 BLOCK *be = &x->block[i];
976 vp8_build_inter_predictors_b(bd, 16, x->e_mbd.subpixel_predict);
977 ENCODEMB_INVOKE(rtcd, subb)(be, bd, 16);
978 x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
980 // set to 0 no way to account for 2nd order DC so discount
982 x->quantize_b(be, bd);
984 distortion += ENCODEMB_INVOKE(rtcd, berr)(be->coeff, bd->dqcoeff);
992 static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};
1005 B_PREDICTION_MODE modes[16];
1007 unsigned char eobs[16];
1012 MV sv_mvp[4]; // save 4 mvp from 8x8
1013 int sv_istep[2]; // save 2 initial step_param for 16x8/8x16
1018 static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
1019 BEST_SEG_INFO *bsi, unsigned int segmentation)
1025 B_PREDICTION_MODE this_mode;
1029 int this_segment_rd = 0;
1030 int label_mv_thresh;
1034 int segmentyrate = 0;
1036 vp8_variance_fn_ptr_t *v_fn_ptr;
1038 ENTROPY_CONTEXT_PLANES t_above, t_left;
1039 ENTROPY_CONTEXT *ta;
1040 ENTROPY_CONTEXT *tl;
1041 ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
1042 ENTROPY_CONTEXT *ta_b;
1043 ENTROPY_CONTEXT *tl_b;
1045 vpx_memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
1046 vpx_memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
1048 ta = (ENTROPY_CONTEXT *)&t_above;
1049 tl = (ENTROPY_CONTEXT *)&t_left;
1050 ta_b = (ENTROPY_CONTEXT *)&t_above_b;
1051 tl_b = (ENTROPY_CONTEXT *)&t_left_b;
1056 v_fn_ptr = &cpi->fn_ptr[segmentation];
1057 labels = vp8_mbsplits[segmentation];
1058 label_count = vp8_mbsplit_count[segmentation];
1060 // 64 makes this threshold really big effectively
1061 // making it so that we very rarely check mvs on
1062 // segments. setting this to 1 would make mv thresh
1063 // roughly equal to what it is for macroblocks
1064 label_mv_thresh = 1 * bsi->mvthresh / label_count ;
1066 // Segmentation method overheads
1067 rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + segmentation);
1068 rate += vp8_cost_mv_ref(SPLITMV, bsi->mdcounts);
1069 this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
1072 for (i = 0; i < label_count; i++)
1074 MV mode_mv[B_MODE_COUNT];
1075 int best_label_rd = INT_MAX;
1076 B_PREDICTION_MODE mode_selected = ZERO4X4;
1077 int bestlabelyrate = 0;
1079 // search for the best motion vector on this segment
1080 for (this_mode = LEFT4X4; this_mode <= NEW4X4 ; this_mode ++)
1085 ENTROPY_CONTEXT_PLANES t_above_s, t_left_s;
1086 ENTROPY_CONTEXT *ta_s;
1087 ENTROPY_CONTEXT *tl_s;
1089 vpx_memcpy(&t_above_s, &t_above, sizeof(ENTROPY_CONTEXT_PLANES));
1090 vpx_memcpy(&t_left_s, &t_left, sizeof(ENTROPY_CONTEXT_PLANES));
1092 ta_s = (ENTROPY_CONTEXT *)&t_above_s;
1093 tl_s = (ENTROPY_CONTEXT *)&t_left_s;
1095 if (this_mode == NEW4X4)
1103 int bestsme = INT_MAX;
1108 // Is the best so far sufficiently good that we cant justify doing and new motion search.
1109 if (best_label_rd < label_mv_thresh)
1112 if(cpi->compressor_speed)
1114 if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8)
1116 bsi->mvp = &bsi->sv_mvp[i];
1117 if (i==1 && segmentation == BLOCK_16X8) bsi->mvp = &bsi->sv_mvp[2];
1119 step_param = bsi->sv_istep[i];
1122 // use previous block's result as next block's MV predictor.
1123 if (segmentation == BLOCK_4X4 && i>0)
1125 bsi->mvp = &(x->e_mbd.block[i-1].bmi.mv.as_mv);
1126 if (i==4 || i==8 || i==12) bsi->mvp = &(x->e_mbd.block[i-4].bmi.mv.as_mv);
1131 further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
1134 int sadpb = x->sadperbit4;
1137 n = vp8_mbsplit_offset[segmentation][i];
1140 e = &x->e_mbd.block[n];
1142 if (cpi->sf.search_method == HEX)
1143 bestsme = vp8_hex_search(x, c, e, bsi->ref_mv,
1144 &mode_mv[NEW4X4], step_param, sadpb, &num00, v_fn_ptr, x->mvsadcost, x->mvcost, bsi->ref_mv);
1148 bestsme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1149 &mode_mv[NEW4X4], step_param,
1150 sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
1155 while (n < further_steps)
1163 thissme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1164 &temp_mv, step_param + n,
1165 sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
1167 if (thissme < bestsme)
1170 mode_mv[NEW4X4].row = temp_mv.row;
1171 mode_mv[NEW4X4].col = temp_mv.col;
1177 sseshift = segmentation_to_sseshift[segmentation];
1179 // Should we do a full search (best quality only)
1180 if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000)
1184 full_mvp.row = bsi->mvp->row >>3;
1185 full_mvp.col = bsi->mvp->col >>3;
1187 thissme = cpi->full_search_sad(x, c, e, &full_mvp,
1188 sadpb / 4, 16, v_fn_ptr, x->mvcost, bsi->ref_mv);
1190 if (thissme < bestsme)
1193 mode_mv[NEW4X4] = e->bmi.mv.as_mv;
1197 // The full search result is actually worse so re-instate the previous best vector
1198 e->bmi.mv.as_mv = mode_mv[NEW4X4];
1203 if (bestsme < INT_MAX)
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, &distortion, &sse);
1212 vp8_skip_fractional_mv_step(x, c, e, &mode_mv[NEW4X4],
1213 bsi->ref_mv, x->errorperbit, v_fn_ptr, x->mvcost, &distortion, &sse);
1217 rate = labels2mode(x, labels, i, this_mode, &mode_mv[this_mode],
1218 bsi->ref_mv, x->mvcost);
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))
1227 distortion = vp8_encode_inter_mb_segment(x, labels, i, IF_RTCD(&cpi->rtcd.encodemb)) / 4;
1229 labelyrate = rdcost_mbsegment_y(x, labels, i, ta_s, tl_s);
1232 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1234 if (this_rd < best_label_rd)
1238 bestlabelyrate = labelyrate;
1239 mode_selected = this_mode;
1240 best_label_rd = this_rd;
1242 vpx_memcpy(ta_b, ta_s, sizeof(ENTROPY_CONTEXT_PLANES));
1243 vpx_memcpy(tl_b, tl_s, sizeof(ENTROPY_CONTEXT_PLANES));
1246 } /*for each 4x4 mode*/
1248 vpx_memcpy(ta, ta_b, sizeof(ENTROPY_CONTEXT_PLANES));
1249 vpx_memcpy(tl, tl_b, sizeof(ENTROPY_CONTEXT_PLANES));
1251 labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected],
1252 bsi->ref_mv, x->mvcost);
1256 segmentyrate += bestlabelyrate;
1257 this_segment_rd += best_label_rd;
1259 if (this_segment_rd >= bsi->segment_rd)
1262 } /* for each label */
1264 if (this_segment_rd < bsi->segment_rd)
1268 bsi->segment_yrate = segmentyrate;
1269 bsi->segment_rd = this_segment_rd;
1270 bsi->segment_num = segmentation;
1272 // store everything needed to come back to this!!
1273 for (i = 0; i < 16; i++)
1275 BLOCKD *bd = &x->e_mbd.block[i];
1277 bsi->mvs[i].as_mv = bd->bmi.mv.as_mv;
1278 bsi->modes[i] = bd->bmi.mode;
1279 bsi->eobs[i] = bd->eob;
1285 void vp8_cal_step_param(int sr, int *sp)
1289 if (sr > MAX_FIRST_STEP) sr = MAX_FIRST_STEP;
1290 else if (sr < 1) sr = 1;
1295 *sp = MAX_MVSEARCH_STEPS - 1 - step;
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,
1307 vpx_memset(&bsi, 0, sizeof(bsi));
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;
1315 for(i = 0; i < 16; i++)
1317 bsi.modes[i] = ZERO4X4;
1320 if(cpi->compressor_speed == 0)
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);
1333 rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1335 if (bsi.segment_rd < best_rd)
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;
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;
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;
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;
1363 /* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range according to the closeness of 2 MV. */
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]);
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]);
1372 rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
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]);
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]);
1383 rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
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) */
1390 bsi.mvp = &bsi.sv_mvp[0];
1391 rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
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;
1402 /* set it to the best */
1403 for (i = 0; i < 16; i++)
1405 BLOCKD *bd = &x->e_mbd.block[i];
1407 bd->bmi.mv.as_mv = bsi.mvs[i].as_mv;
1408 bd->bmi.mode = bsi.modes[i];
1409 bd->eob = bsi.eobs[i];
1412 *returntotrate = bsi.r;
1413 *returndistortion = bsi.d;
1414 *returnyrate = bsi.segment_yrate;
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];
1420 for (i = 0; i < x->partition_info->count; i++)
1424 j = vp8_mbsplit_offset[bsi.segment_num][i];
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;
1430 return bsi.segment_rd;
1433 static void swap(int *x,int *y)
1442 static void quicksortmv(int arr[],int left, int right)
1444 int lidx,ridx,pivot;
1451 pivot = (left + right)/2;
1453 while(lidx <=pivot && ridx >=pivot)
1455 while(arr[lidx] < arr[pivot] && lidx <= pivot)
1457 while(arr[ridx] > arr[pivot] && ridx >= pivot)
1459 swap(&arr[lidx], &arr[ridx]);
1467 else if(ridx+1 == pivot)
1473 quicksortmv(arr, left, pivot - 1);
1474 quicksortmv(arr, pivot + 1, right);
1478 static void quicksortsad(int arr[],int idx[], int left, int right)
1480 int lidx,ridx,pivot;
1487 pivot = (left + right)/2;
1489 while(lidx <=pivot && ridx >=pivot)
1491 while(arr[lidx] < arr[pivot] && lidx <= pivot)
1493 while(arr[ridx] > arr[pivot] && ridx >= pivot)
1495 swap(&arr[lidx], &arr[ridx]);
1496 swap(&idx[lidx], &idx[ridx]);
1504 else if(ridx+1 == pivot)
1510 quicksortsad(arr, idx, left, pivot - 1);
1511 quicksortsad(arr, idx, pivot + 1, right);
1515 //The improved MV prediction
1520 const MODE_INFO *here,
1523 int *ref_frame_sign_bias,
1528 const MODE_INFO *above = here - xd->mode_info_stride;
1529 const MODE_INFO *left = here - 1;
1530 const MODE_INFO *aboveleft = above - 1;
1544 if(here->mbmi.ref_frame != INTRA_FRAME)
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;
1549 // read in 3 nearby block's MVs from current frame as prediction candidates.
1550 if (above->mbmi.ref_frame != INTRA_FRAME)
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;
1557 if (left->mbmi.ref_frame != INTRA_FRAME)
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;
1564 if (aboveleft->mbmi.ref_frame != INTRA_FRAME)
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;
1572 // read in 5 nearby block's MVs from last frame.
1573 if(cpi->common.last_frame_type != KEY_FRAME)
1575 mb_offset = (-xd->mb_to_top_edge/128 + 1) * (xd->mode_info_stride +1) + (-xd->mb_to_left_edge/128 +1) ;
1577 // current in last frame
1578 if (cpi->lf_ref_frame[mb_offset] != INTRA_FRAME)
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];
1586 // above in last frame
1587 if (cpi->lf_ref_frame[mb_offset - xd->mode_info_stride-1] != INTRA_FRAME)
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];
1595 // left in last frame
1596 if (cpi->lf_ref_frame[mb_offset-1] != INTRA_FRAME)
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];
1604 // right in last frame
1605 if (cpi->lf_ref_frame[mb_offset +1] != INTRA_FRAME)
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];
1613 // below in last frame
1614 if (cpi->lf_ref_frame[mb_offset + xd->mode_info_stride +1] != INTRA_FRAME)
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];
1623 for(i=0; i< vcnt; i++)
1625 if(near_ref[near_sadidx[i]] != INTRA_FRAME)
1627 if(here->mbmi.ref_frame == near_ref[near_sadidx[i]])
1629 mv.as_int = near_mvs[near_sadidx[i]].as_int;
1642 for(i=0; i<vcnt; i++)
1644 mvx[i] = near_mvs[i].as_mv.row;
1645 mvy[i] = near_mvs[i].as_mv.col;
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];
1654 //sr is set to 0 to allow calling function to decide the search range.
1659 /* Set up return values */
1661 vp8_clamp_mv(mvp, xd);
1664 void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[])
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
1669 //calculate sad for current frame 3 nearby MBs.
1670 if( xd->mb_to_top_edge==0 && xd->mb_to_left_edge ==0)
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);
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);
1688 if(cpi->common.last_frame_type != KEY_FRAME)
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;
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;
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);
1710 if(cpi->common.last_frame_type != KEY_FRAME)
1712 quicksortsad(near_sad, near_sadidx, 0, 7);
1715 quicksortsad(near_sad, near_sadidx, 0, 2);
1719 void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int recon_uvoffset, int *returnrate, int *returndistortion, int *returnintra)
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;
1728 MV mode_mv[MB_MODE_COUNT];
1729 MB_PREDICTION_MODE this_mode;
1731 int best_mode_index = 0;
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);
1745 int best_yrd = INT_MAX;
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];
1752 MB_PREDICTION_MODE uv_intra_mode;
1754 int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
1756 int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7)
1758 MV frame_nearest_mv[4];
1759 MV frame_near_mv[4];
1760 MV frame_best_ref_mv[4];
1761 int frame_mdcounts[4][4];
1762 int frame_lf_or_gf[4];
1763 unsigned char *y_buffer[4];
1764 unsigned char *u_buffer[4];
1765 unsigned char *v_buffer[4];
1767 vpx_memset(&best_mbmode, 0, sizeof(best_mbmode));
1769 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1771 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
1773 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[LAST_FRAME], &frame_near_mv[LAST_FRAME],
1774 &frame_best_ref_mv[LAST_FRAME], frame_mdcounts[LAST_FRAME], LAST_FRAME, cpi->common.ref_frame_sign_bias);
1776 y_buffer[LAST_FRAME] = lst_yv12->y_buffer + recon_yoffset;
1777 u_buffer[LAST_FRAME] = lst_yv12->u_buffer + recon_uvoffset;
1778 v_buffer[LAST_FRAME] = lst_yv12->v_buffer + recon_uvoffset;
1780 frame_lf_or_gf[LAST_FRAME] = 0;
1783 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1785 YV12_BUFFER_CONFIG *gld_yv12 = &cpi->common.yv12_fb[cpi->common.gld_fb_idx];
1787 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[GOLDEN_FRAME], &frame_near_mv[GOLDEN_FRAME],
1788 &frame_best_ref_mv[GOLDEN_FRAME], frame_mdcounts[GOLDEN_FRAME], GOLDEN_FRAME, cpi->common.ref_frame_sign_bias);
1790 y_buffer[GOLDEN_FRAME] = gld_yv12->y_buffer + recon_yoffset;
1791 u_buffer[GOLDEN_FRAME] = gld_yv12->u_buffer + recon_uvoffset;
1792 v_buffer[GOLDEN_FRAME] = gld_yv12->v_buffer + recon_uvoffset;
1794 frame_lf_or_gf[GOLDEN_FRAME] = 1;
1797 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1799 YV12_BUFFER_CONFIG *alt_yv12 = &cpi->common.yv12_fb[cpi->common.alt_fb_idx];
1801 vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[ALTREF_FRAME], &frame_near_mv[ALTREF_FRAME],
1802 &frame_best_ref_mv[ALTREF_FRAME], frame_mdcounts[ALTREF_FRAME], ALTREF_FRAME, cpi->common.ref_frame_sign_bias);
1804 y_buffer[ALTREF_FRAME] = alt_yv12->y_buffer + recon_yoffset;
1805 u_buffer[ALTREF_FRAME] = alt_yv12->u_buffer + recon_uvoffset;
1806 v_buffer[ALTREF_FRAME] = alt_yv12->v_buffer + recon_uvoffset;
1808 frame_lf_or_gf[ALTREF_FRAME] = 1;
1811 *returnintra = INT_MAX;
1812 cpi->mbs_tested_so_far++; // Count of the number of MBs tested so far this frame
1816 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(cpi->prob_intra_coded);
1818 // Special case treatment when GF and ARF are not sensible options for reference
1819 if (cpi->ref_frame_flags == VP8_LAST_FLAG)
1821 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1822 + vp8_cost_zero(255);
1823 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1825 + vp8_cost_zero(128);
1826 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1828 + vp8_cost_one(128);
1832 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1833 + vp8_cost_zero(cpi->prob_last_coded);
1834 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1835 + vp8_cost_one(cpi->prob_last_coded)
1836 + vp8_cost_zero(cpi->prob_gf_coded);
1837 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1838 + vp8_cost_one(cpi->prob_last_coded)
1839 + vp8_cost_one(cpi->prob_gf_coded);
1842 vpx_memset(mode_mv, 0, sizeof(mode_mv));
1844 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1845 vp8_rd_pick_intra_mbuv_mode(cpi, x, &uv_intra_rate, &uv_intra_rate_tokenonly, &uv_intra_distortion);
1846 uv_intra_mode = x->e_mbd.mode_info_context->mbmi.uv_mode;
1848 for (mode_index = 0; mode_index < MAX_MODES; mode_index++)
1850 int this_rd = INT_MAX;
1851 int lf_or_gf = 0; // Lat Frame (01) or gf/arf (1)
1852 int disable_skip = 0;
1855 // Experimental debug code.
1856 // Record of rd values recorded for this MB. -1 indicates not measured
1857 //all_rds[mode_index] = -1;
1858 //all_rates[mode_index] = -1;
1859 //all_dist[mode_index] = -1;
1860 //intermodecost[mode_index] = -1;
1862 // Test best rd so far against threshold for trying this mode.
1863 if (best_rd <= cpi->rd_threshes[mode_index])
1866 // These variables hold are rolling total cost and distortion for this mode
1870 this_mode = vp8_mode_order[mode_index];
1872 x->e_mbd.mode_info_context->mbmi.mode = this_mode;
1873 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1874 x->e_mbd.mode_info_context->mbmi.ref_frame = vp8_ref_frame_order[mode_index];
1876 // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
1877 // unless ARNR filtering is enabled in which case we want
1878 // an unfiltered alternative
1879 if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
1881 if (this_mode != ZEROMV || x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
1885 /* everything but intra */
1886 if (x->e_mbd.mode_info_context->mbmi.ref_frame)
1888 x->e_mbd.pre.y_buffer = y_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1889 x->e_mbd.pre.u_buffer = u_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1890 x->e_mbd.pre.v_buffer = v_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1891 mode_mv[NEARESTMV] = frame_nearest_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1892 mode_mv[NEARMV] = frame_near_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1893 best_ref_mv = frame_best_ref_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1894 vpx_memcpy(mdcounts, frame_mdcounts[x->e_mbd.mode_info_context->mbmi.ref_frame], sizeof(mdcounts));
1895 lf_or_gf = frame_lf_or_gf[x->e_mbd.mode_info_context->mbmi.ref_frame];
1898 if(x->e_mbd.mode_info_context->mbmi.mode == NEWMV)
1902 vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] );
1906 vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, &mvp,
1907 x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
1909 /* adjust mvp to make sure it is within MV range */
1910 if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL)
1911 mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL;
1912 else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL)
1913 mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL;
1914 if(mvp.col > best_ref_mv.col + MAX_FULL_PEL_VAL)
1915 mvp.col = best_ref_mv.col + MAX_FULL_PEL_VAL;
1916 else if(mvp.col < best_ref_mv.col - MAX_FULL_PEL_VAL)
1917 mvp.col = best_ref_mv.col - MAX_FULL_PEL_VAL;
1920 // Check to see if the testing frequency for this mode is at its max
1921 // If so then prevent it from being tested and increase the threshold for its testing
1922 if (cpi->mode_test_hit_counts[mode_index] && (cpi->mode_check_freq[mode_index] > 1))
1924 if (cpi->mbs_tested_so_far <= cpi->mode_check_freq[mode_index] * cpi->mode_test_hit_counts[mode_index])
1926 // Increase the threshold for coding this mode to make it less likely to be chosen
1927 cpi->rd_thresh_mult[mode_index] += 4;
1929 if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
1930 cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1932 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
1938 // 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
1939 cpi->mode_test_hit_counts[mode_index] ++;
1941 // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1942 if (cpi->zbin_mode_boost_enabled)
1944 if ( vp8_ref_frame_order[mode_index] == INTRA_FRAME )
1945 cpi->zbin_mode_boost = 0;
1948 if (vp8_mode_order[mode_index] == ZEROMV)
1950 if (vp8_ref_frame_order[mode_index] != LAST_FRAME)
1951 cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1953 cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
1955 else if (vp8_mode_order[mode_index] == SPLITMV)
1956 cpi->zbin_mode_boost = 0;
1958 cpi->zbin_mode_boost = MV_ZBIN_BOOST;
1961 vp8_update_zbin_extra(cpi, x);
1970 // Note the rate value returned here includes the cost of coding the BPRED mode : x->mbmode_cost[x->e_mbd.frame_type][BPRED];
1971 tmp_rd = vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate, &rate_y, &distortion, best_yrd);
1973 distortion2 += distortion;
1975 if(tmp_rd < best_yrd)
1977 rate2 += uv_intra_rate;
1978 rate_uv = uv_intra_rate_tokenonly;
1979 distortion2 += uv_intra_distortion;
1980 distortion_uv = uv_intra_distortion;
1995 this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME) ? cpi->rd_threshes[THR_NEWMV] : cpi->rd_threshes[THR_NEWA];
1996 this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == GOLDEN_FRAME) ? cpi->rd_threshes[THR_NEWG]: this_rd_thresh;
1998 tmp_rd = vp8_rd_pick_best_mbsegmentation(cpi, x, &best_ref_mv,
2000 &rate, &rate_y, &distortion, this_rd_thresh) ;
2003 distortion2 += distortion;
2005 // If even the 'Y' rd value of split is higher than best so far then dont bother looking at UV
2006 if (tmp_rd < best_yrd)
2008 // Now work out UV cost and add it in
2009 vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
2011 distortion2 += distortion_uv;
2024 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
2025 RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby)
2027 macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb)) ;
2029 distortion2 += distortion;
2030 rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
2031 rate2 += uv_intra_rate;
2032 rate_uv = uv_intra_rate_tokenonly;
2033 distortion2 += uv_intra_distortion;
2034 distortion_uv = uv_intra_distortion;
2039 // Decrement full search counter
2040 if (cpi->check_freq[lf_or_gf] > 0)
2041 cpi->check_freq[lf_or_gf] --;
2045 int bestsme = INT_MAX;
2046 int step_param = cpi->sf.first_step;
2051 int col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3;
2052 int col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3;
2053 int row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3;
2054 int row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3;
2056 int tmp_col_min = x->mv_col_min;
2057 int tmp_col_max = x->mv_col_max;
2058 int tmp_row_min = x->mv_row_min;
2059 int tmp_row_max = x->mv_row_max;
2061 // Get intersection of UMV window and valid MV window to reduce # of checks in diamond search.
2062 if (x->mv_col_min < col_min )
2063 x->mv_col_min = col_min;
2064 if (x->mv_col_max > col_max )
2065 x->mv_col_max = col_max;
2066 if (x->mv_row_min < row_min )
2067 x->mv_row_min = row_min;
2068 if (x->mv_row_max > row_max )
2069 x->mv_row_max = row_max;
2071 //adjust search range according to sr from mv prediction
2075 // Work out how long a search we should do
2076 search_range = MAXF(abs(best_ref_mv.col), abs(best_ref_mv.row)) >> 3;
2078 if (search_range >= x->vector_range)
2079 x->vector_range = search_range;
2080 else if (x->vector_range > cpi->sf.min_fs_radius)
2083 // Initial step/diamond search
2085 int sadpb = x->sadperbit16;
2087 if (cpi->sf.search_method == HEX)
2089 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);
2090 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2091 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2095 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
2096 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2097 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2099 // Further step/diamond searches as necessary
2101 further_steps = (cpi->sf.max_step_search_steps - 1) - step_param;
2106 while (n < further_steps)
2114 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
2116 if (thissme < bestsme)
2119 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2120 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2124 d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2125 d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2133 // Should we do a full search
2134 if (!cpi->check_freq[lf_or_gf] || cpi->do_full[lf_or_gf])
2137 int full_flag_thresh = 0;
2139 // Update x->vector_range based on best vector found in step search
2140 search_range = MAXF(abs((mvp.row>>3) - d->bmi.mv.as_mv.row), abs((mvp.col>>3) - d->bmi.mv.as_mv.col));
2141 //search_range *= 1.4; //didn't improve PSNR
2143 if (search_range > x->vector_range)
2144 x->vector_range = search_range;
2146 search_range = x->vector_range;
2149 search_range = (search_range > cpi->sf.max_fs_radius) ? cpi->sf.max_fs_radius : search_range;
2151 //add this to reduce full search range.
2152 if(sr<=3 && search_range > 8) search_range = 8;
2155 int sadpb = x->sadperbit16 >> 2;
2156 /* use diamond search result as full search staring point */
2157 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);
2160 // Barrier threshold to initiating full search
2161 // full_flag_thresh = 10 + (thissme >> 7);
2162 if ((thissme + full_flag_thresh) < bestsme)
2164 cpi->do_full[lf_or_gf] ++;
2167 else if (thissme < bestsme)
2171 cpi->do_full[lf_or_gf] = cpi->do_full[lf_or_gf] >> 1;
2172 cpi->check_freq[lf_or_gf] = cpi->sf.full_freq[lf_or_gf];
2174 // The full search result is actually worse so re-instate the previous best vector
2175 d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2176 d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2180 x->mv_col_min = tmp_col_min;
2181 x->mv_col_max = tmp_col_max;
2182 x->mv_row_min = tmp_row_min;
2183 x->mv_row_max = tmp_row_max;
2185 if (bestsme < INT_MAX)
2187 int dis; /* TODO: use dis in distortion calculation later. */
2189 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, &dis, &sse);
2192 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2193 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2195 // Add the new motion vector cost to our rolling cost variable
2196 rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96);
2203 // Clip "next_nearest" so that it does not extend to far out of image
2204 if (mode_mv[this_mode].col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
2205 mode_mv[this_mode].col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
2206 else if (mode_mv[this_mode].col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
2207 mode_mv[this_mode].col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
2209 if (mode_mv[this_mode].row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
2210 mode_mv[this_mode].row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
2211 else if (mode_mv[this_mode].row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
2212 mode_mv[this_mode].row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
2214 // 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.
2215 if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) &&
2216 ((mode_mv[this_mode].row == 0) && (mode_mv[this_mode].col == 0)))
2221 // Trap vectors that reach beyond the UMV borders
2222 // Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point
2223 // because of the lack of break statements in the previous two cases.
2224 if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) ||
2225 ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max))
2228 vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);
2229 vp8_build_inter16x16_predictors_mby(&x->e_mbd);
2231 if (cpi->active_map_enabled && x->active_ptr[0] == 0) {
2234 else if (x->encode_breakout)
2238 int threshold = (xd->block[0].dequant[1]
2239 * xd->block[0].dequant[1] >>4);
2241 if(threshold < x->encode_breakout)
2242 threshold = x->encode_breakout;
2244 VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16var)
2245 (x->src.y_buffer, x->src.y_stride,
2246 x->e_mbd.predictor, 16, &sse, &sum);
2248 if (sse < threshold)
2250 // Check u and v to make sure skip is ok
2252 /* If theres is no codeable 2nd order dc
2253 or a very small uniform pixel change change */
2254 if (abs(sum) < (xd->block[24].dequant[0]<<2)||
2255 ((sum * sum>>8) > sse && abs(sum) <128))
2257 sse2 = VP8_UVSSE(x, IF_RTCD(&cpi->rtcd.variance));
2259 if (sse2 * 2 < threshold)
2262 distortion2 = sse + sse2;
2265 /* for best_yrd calculation */
2267 distortion_uv = sse2;
2270 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
2279 //intermodecost[mode_index] = vp8_cost_mv_ref(this_mode, mdcounts); // Experimental debug code
2281 // Add in the Mv/mode cost
2282 rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
2284 // Y cost and distortion
2285 macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
2287 distortion2 += distortion;
2289 // UV cost and distortion
2290 vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
2292 distortion2 += distortion_uv;
2299 // Where skip is allowable add in the default per mb cost for the no skip case.
2300 // where we then decide to skip we have to delete this and replace it with the
2301 // cost of signallying a skip
2302 if (cpi->common.mb_no_coeff_skip)
2304 other_cost += vp8_cost_bit(cpi->prob_skip_false, 0);
2305 rate2 += other_cost;
2308 // Estimate the reference frame signaling cost and add it to the rolling cost variable.
2309 rate2 += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2313 // Test for the condition where skip block will be activated because there are no non zero coefficients and make any necessary adjustment for rate
2314 if (cpi->common.mb_no_coeff_skip)
2320 for (i = 0; i <= 24; i++)
2322 tteob += x->e_mbd.block[i].eob;
2327 rate2 -= (rate_y + rate_uv);
2328 //for best_yrd calculation
2331 // Back out no skip flag costing and add in skip flag costing
2332 if (cpi->prob_skip_false)
2336 prob_skip_cost = vp8_cost_bit(cpi->prob_skip_false, 1);
2337 prob_skip_cost -= vp8_cost_bit(cpi->prob_skip_false, 0);
2338 rate2 += prob_skip_cost;
2339 other_cost += prob_skip_cost;
2343 // Calculate the final RD estimate for this mode
2344 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
2347 // Experimental debug code.
2348 //all_rds[mode_index] = this_rd;
2349 //all_rates[mode_index] = rate2;
2350 //all_dist[mode_index] = distortion2;
2352 // Keep record of best intra distortion
2353 if ((x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) &&
2354 (this_rd < best_intra_rd) )
2356 best_intra_rd = this_rd;
2357 *returnintra = distortion2 ;
2360 // Did this mode help.. i.i is it the new best mode
2361 if (this_rd < best_rd || x->skip)
2363 // Note index of best mode so far
2364 best_mode_index = mode_index;
2366 if (this_mode <= B_PRED)
2368 x->e_mbd.mode_info_context->mbmi.uv_mode = uv_intra_mode;
2371 other_cost += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2373 /* Calculate the final y RD estimate for this mode */
2374 best_yrd = RDCOST(x->rdmult, x->rddiv, (rate2-rate_uv-other_cost),
2375 (distortion2-distortion_uv));
2377 *returnrate = rate2;
2378 *returndistortion = distortion2;
2380 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, sizeof(MB_MODE_INFO));
2381 vpx_memcpy(&best_partition, x->partition_info, sizeof(PARTITION_INFO));
2383 for (i = 0; i < 16; i++)
2385 vpx_memcpy(&best_bmodes[i], &x->e_mbd.block[i].bmi, sizeof(B_MODE_INFO));
2388 // Testing this mode gave rise to an improvement in best error score. Lower threshold a bit for next time
2389 cpi->rd_thresh_mult[mode_index] = (cpi->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ? cpi->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT;
2390 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2393 // If the mode did not help improve the best error case then raise the threshold for testing that mode next time around.
2396 cpi->rd_thresh_mult[mode_index] += 4;
2398 if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
2399 cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
2401 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2409 // Reduce the activation RD thresholds for the best choice mode
2410 if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2)))
2412 int best_adjustment = (cpi->rd_thresh_mult[best_mode_index] >> 2);
2414 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;
2415 cpi->rd_threshes[best_mode_index] = (cpi->rd_baseline_thresh[best_mode_index] >> 7) * cpi->rd_thresh_mult[best_mode_index];
2417 // If we chose a split mode then reset the new MV thresholds as well
2418 /*if ( vp8_mode_order[best_mode_index] == SPLITMV )
2420 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWMV] >> 4);
2421 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;
2422 cpi->rd_threshes[THR_NEWMV] = (cpi->rd_baseline_thresh[THR_NEWMV] >> 7) * cpi->rd_thresh_mult[THR_NEWMV];
2424 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWG] >> 4);
2425 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;
2426 cpi->rd_threshes[THR_NEWG] = (cpi->rd_baseline_thresh[THR_NEWG] >> 7) * cpi->rd_thresh_mult[THR_NEWG];
2428 best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWA] >> 4);
2429 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;
2430 cpi->rd_threshes[THR_NEWA] = (cpi->rd_baseline_thresh[THR_NEWA] >> 7) * cpi->rd_thresh_mult[THR_NEWA];
2435 // If we have chosen new mv or split then decay the full search check count more quickly.
2436 if ((vp8_mode_order[best_mode_index] == NEWMV) || (vp8_mode_order[best_mode_index] == SPLITMV))
2438 int lf_or_gf = (vp8_ref_frame_order[best_mode_index] == LAST_FRAME) ? 0 : 1;
2440 if (cpi->check_freq[lf_or_gf] && !cpi->do_full[lf_or_gf])
2442 cpi->check_freq[lf_or_gf] --;
2446 // Keep a record of best mode index that we chose
2447 cpi->last_best_mode_index = best_mode_index;
2449 // Note how often each mode chosen as best
2450 cpi->mode_chosen_counts[best_mode_index] ++;
2453 if (cpi->is_src_frame_alt_ref && (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME))
2455 best_mbmode.mode = ZEROMV;
2456 best_mbmode.ref_frame = ALTREF_FRAME;
2457 best_mbmode.mv.as_int = 0;
2458 best_mbmode.uv_mode = 0;
2459 best_mbmode.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
2460 best_mbmode.partitioning = 0;
2462 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2463 vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2465 for (i = 0; i < 16; i++)
2467 vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
2470 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2475 if(best_mbmode.mode <= B_PRED)
2478 for (i = 0; i < 16; i++)
2480 best_bmodes[i].mv.as_int = 0;
2485 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2486 vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2488 for (i = 0; i < 16; i++)
2490 vpx_memcpy(&x->e_mbd.block[i].bmi, &best_bmodes[i], sizeof(B_MODE_INFO));
2493 x->e_mbd.mode_info_context->mbmi.mv.as_mv = x->e_mbd.block[15].bmi.mv.as_mv;