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 <limits.h>
13 #include "vpx_config.h"
14 #include "onyx_int.h"
15 #include "modecosts.h"
16 #include "encodeintra.h"
17 #include "vp8/common/common.h"
18 #include "vp8/common/entropymode.h"
19 #include "pickinter.h"
20 #include "vp8/common/findnearmv.h"
21 #include "encodemb.h"
22 #include "vp8/common/reconinter.h"
23 #include "vp8/common/reconintra4x4.h"
24 #include "vp8/common/variance.h"
25 #include "mcomp.h"
26 #include "rdopt.h"
27 #include "vpx_mem/vpx_mem.h"
28 #if CONFIG_TEMPORAL_DENOISING
29 #include "denoising.h"
30 #endif
31 
32 extern int VP8_UVSSE(MACROBLOCK *x);
33 
34 #ifdef SPEEDSTATS
35 extern unsigned int cnt_pm;
36 #endif
37 
38 extern const int vp8_ref_frame_order[MAX_MODES];
39 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
40 
41 extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]);
42 
vp8_skip_fractional_mv_step(MACROBLOCK * mb,BLOCK * b,BLOCKD * d,int_mv * bestmv,int_mv * ref_mv,int error_per_bit,const vp8_variance_fn_ptr_t * vfp,int * mvcost[2],int * distortion,unsigned int * sse)43 int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d,
44                                 int_mv *bestmv, int_mv *ref_mv,
45                                 int error_per_bit,
46                                 const vp8_variance_fn_ptr_t *vfp,
47                                 int *mvcost[2], int *distortion,
48                                 unsigned int *sse)
49 {
50     (void) b;
51     (void) d;
52     (void) ref_mv;
53     (void) error_per_bit;
54     (void) vfp;
55     (void) mvcost;
56     (void) distortion;
57     (void) sse;
58     bestmv->as_mv.row <<= 3;
59     bestmv->as_mv.col <<= 3;
60     return 0;
61 }
62 
63 
vp8_get_inter_mbpred_error(MACROBLOCK * mb,const vp8_variance_fn_ptr_t * vfp,unsigned int * sse,int_mv this_mv)64 int vp8_get_inter_mbpred_error(MACROBLOCK *mb,
65                                   const vp8_variance_fn_ptr_t *vfp,
66                                   unsigned int *sse,
67                                   int_mv this_mv)
68 {
69 
70     BLOCK *b = &mb->block[0];
71     BLOCKD *d = &mb->e_mbd.block[0];
72     unsigned char *what = (*(b->base_src) + b->src);
73     int what_stride = b->src_stride;
74     int pre_stride = mb->e_mbd.pre.y_stride;
75     unsigned char *in_what = mb->e_mbd.pre.y_buffer + d->offset ;
76     int in_what_stride = pre_stride;
77     int xoffset = this_mv.as_mv.col & 7;
78     int yoffset = this_mv.as_mv.row & 7;
79 
80     in_what += (this_mv.as_mv.row >> 3) * pre_stride + (this_mv.as_mv.col >> 3);
81 
82     if (xoffset | yoffset)
83     {
84         return vfp->svf(in_what, in_what_stride, xoffset, yoffset, what, what_stride, sse);
85     }
86     else
87     {
88         return vfp->vf(what, what_stride, in_what, in_what_stride, sse);
89     }
90 
91 }
92 
93 
vp8_get4x4sse_cs_c(const unsigned char * src_ptr,int source_stride,const unsigned char * ref_ptr,int recon_stride)94 unsigned int vp8_get4x4sse_cs_c
95 (
96     const unsigned char *src_ptr,
97     int  source_stride,
98     const unsigned char *ref_ptr,
99     int  recon_stride
100 )
101 {
102     int distortion = 0;
103     int r, c;
104 
105     for (r = 0; r < 4; r++)
106     {
107         for (c = 0; c < 4; c++)
108         {
109             int diff = src_ptr[c] - ref_ptr[c];
110             distortion += diff * diff;
111         }
112 
113         src_ptr += source_stride;
114         ref_ptr += recon_stride;
115     }
116 
117     return distortion;
118 }
119 
get_prediction_error(BLOCK * be,BLOCKD * b)120 static int get_prediction_error(BLOCK *be, BLOCKD *b)
121 {
122     unsigned char *sptr;
123     unsigned char *dptr;
124     sptr = (*(be->base_src) + be->src);
125     dptr = b->predictor;
126 
127     return vp8_get4x4sse_cs(sptr, be->src_stride, dptr, 16);
128 
129 }
130 
pick_intra4x4block(MACROBLOCK * x,int ib,B_PREDICTION_MODE * best_mode,const int * mode_costs,int * bestrate,int * bestdistortion)131 static int pick_intra4x4block(
132     MACROBLOCK *x,
133     int ib,
134     B_PREDICTION_MODE *best_mode,
135     const int *mode_costs,
136 
137     int *bestrate,
138     int *bestdistortion)
139 {
140 
141     BLOCKD *b = &x->e_mbd.block[ib];
142     BLOCK *be = &x->block[ib];
143     int dst_stride = x->e_mbd.dst.y_stride;
144     unsigned char *dst = x->e_mbd.dst.y_buffer + b->offset;
145     B_PREDICTION_MODE mode;
146     int best_rd = INT_MAX;
147     int rate;
148     int distortion;
149 
150     unsigned char *Above = dst - dst_stride;
151     unsigned char *yleft = dst - 1;
152     unsigned char top_left = Above[-1];
153 
154     for (mode = B_DC_PRED; mode <= B_HE_PRED; mode++)
155     {
156         int this_rd;
157 
158         rate = mode_costs[mode];
159 
160         vp8_intra4x4_predict(Above, yleft, dst_stride, mode,
161                              b->predictor, 16, top_left);
162         distortion = get_prediction_error(be, b);
163         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
164 
165         if (this_rd < best_rd)
166         {
167             *bestrate = rate;
168             *bestdistortion = distortion;
169             best_rd = this_rd;
170             *best_mode = mode;
171         }
172     }
173 
174     b->bmi.as_mode = *best_mode;
175     vp8_encode_intra4x4block(x, ib);
176     return best_rd;
177 }
178 
179 
pick_intra4x4mby_modes(MACROBLOCK * mb,int * Rate,int * best_dist)180 static int pick_intra4x4mby_modes
181 (
182     MACROBLOCK *mb,
183     int *Rate,
184     int *best_dist
185 )
186 {
187     MACROBLOCKD *const xd = &mb->e_mbd;
188     int i;
189     int cost = mb->mbmode_cost [xd->frame_type] [B_PRED];
190     int error;
191     int distortion = 0;
192     const int *bmode_costs;
193 
194     intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->dst.y_stride + 16);
195 
196     bmode_costs = mb->inter_bmode_costs;
197 
198     for (i = 0; i < 16; i++)
199     {
200         MODE_INFO *const mic = xd->mode_info_context;
201         const int mis = xd->mode_info_stride;
202 
203         B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
204         int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(d);
205 
206         if (mb->e_mbd.frame_type == KEY_FRAME)
207         {
208             const B_PREDICTION_MODE A = above_block_mode(mic, i, mis);
209             const B_PREDICTION_MODE L = left_block_mode(mic, i);
210 
211             bmode_costs  = mb->bmode_costs[A][L];
212         }
213 
214 
215         pick_intra4x4block(mb, i, &best_mode, bmode_costs, &r, &d);
216 
217         cost += r;
218         distortion += d;
219         mic->bmi[i].as_mode = best_mode;
220 
221         /* Break out case where we have already exceeded best so far value
222          * that was passed in
223          */
224         if (distortion > *best_dist)
225             break;
226     }
227 
228     *Rate = cost;
229 
230     if (i == 16)
231     {
232         *best_dist = distortion;
233         error = RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
234     }
235     else
236     {
237         *best_dist = INT_MAX;
238         error = INT_MAX;
239     }
240 
241     return error;
242 }
243 
pick_intra_mbuv_mode(MACROBLOCK * mb)244 static void pick_intra_mbuv_mode(MACROBLOCK *mb)
245 {
246 
247     MACROBLOCKD *x = &mb->e_mbd;
248     unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
249     unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride;
250     unsigned char *usrc_ptr = (mb->block[16].src + *mb->block[16].base_src);
251     unsigned char *vsrc_ptr = (mb->block[20].src + *mb->block[20].base_src);
252     int uvsrc_stride = mb->block[16].src_stride;
253     unsigned char uleft_col[8];
254     unsigned char vleft_col[8];
255     unsigned char utop_left = uabove_row[-1];
256     unsigned char vtop_left = vabove_row[-1];
257     int i, j;
258     int expected_udc;
259     int expected_vdc;
260     int shift;
261     int Uaverage = 0;
262     int Vaverage = 0;
263     int diff;
264     int pred_error[4] = {0, 0, 0, 0}, best_error = INT_MAX;
265     MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
266 
267 
268     for (i = 0; i < 8; i++)
269     {
270         uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
271         vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
272     }
273 
274     if (!x->up_available && !x->left_available)
275     {
276         expected_udc = 128;
277         expected_vdc = 128;
278     }
279     else
280     {
281         shift = 2;
282 
283         if (x->up_available)
284         {
285 
286             for (i = 0; i < 8; i++)
287             {
288                 Uaverage += uabove_row[i];
289                 Vaverage += vabove_row[i];
290             }
291 
292             shift ++;
293 
294         }
295 
296         if (x->left_available)
297         {
298             for (i = 0; i < 8; i++)
299             {
300                 Uaverage += uleft_col[i];
301                 Vaverage += vleft_col[i];
302             }
303 
304             shift ++;
305 
306         }
307 
308         expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
309         expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
310     }
311 
312 
313     for (i = 0; i < 8; i++)
314     {
315         for (j = 0; j < 8; j++)
316         {
317 
318             int predu = uleft_col[i] + uabove_row[j] - utop_left;
319             int predv = vleft_col[i] + vabove_row[j] - vtop_left;
320             int u_p, v_p;
321 
322             u_p = usrc_ptr[j];
323             v_p = vsrc_ptr[j];
324 
325             if (predu < 0)
326                 predu = 0;
327 
328             if (predu > 255)
329                 predu = 255;
330 
331             if (predv < 0)
332                 predv = 0;
333 
334             if (predv > 255)
335                 predv = 255;
336 
337 
338             diff = u_p - expected_udc;
339             pred_error[DC_PRED] += diff * diff;
340             diff = v_p - expected_vdc;
341             pred_error[DC_PRED] += diff * diff;
342 
343 
344             diff = u_p - uabove_row[j];
345             pred_error[V_PRED] += diff * diff;
346             diff = v_p - vabove_row[j];
347             pred_error[V_PRED] += diff * diff;
348 
349 
350             diff = u_p - uleft_col[i];
351             pred_error[H_PRED] += diff * diff;
352             diff = v_p - vleft_col[i];
353             pred_error[H_PRED] += diff * diff;
354 
355 
356             diff = u_p - predu;
357             pred_error[TM_PRED] += diff * diff;
358             diff = v_p - predv;
359             pred_error[TM_PRED] += diff * diff;
360 
361 
362         }
363 
364         usrc_ptr += uvsrc_stride;
365         vsrc_ptr += uvsrc_stride;
366 
367         if (i == 3)
368         {
369             usrc_ptr = (mb->block[18].src + *mb->block[18].base_src);
370             vsrc_ptr = (mb->block[22].src + *mb->block[22].base_src);
371         }
372 
373 
374 
375     }
376 
377 
378     for (i = DC_PRED; i <= TM_PRED; i++)
379     {
380         if (best_error > pred_error[i])
381         {
382             best_error = pred_error[i];
383             best_mode = (MB_PREDICTION_MODE)i;
384         }
385     }
386 
387 
388     mb->e_mbd.mode_info_context->mbmi.uv_mode = best_mode;
389 
390 }
391 
update_mvcount(MACROBLOCK * x,int_mv * best_ref_mv)392 static void update_mvcount(MACROBLOCK *x, int_mv *best_ref_mv)
393 {
394     MACROBLOCKD *xd = &x->e_mbd;
395     /* Split MV modes currently not supported when RD is nopt enabled,
396      * therefore, only need to modify MVcount in NEWMV mode. */
397     if (xd->mode_info_context->mbmi.mode == NEWMV)
398     {
399         x->MVcount[0][mv_max+((xd->mode_info_context->mbmi.mv.as_mv.row -
400                                       best_ref_mv->as_mv.row) >> 1)]++;
401         x->MVcount[1][mv_max+((xd->mode_info_context->mbmi.mv.as_mv.col -
402                                       best_ref_mv->as_mv.col) >> 1)]++;
403     }
404 }
405 
406 
407 #if CONFIG_MULTI_RES_ENCODING
408 static
get_lower_res_motion_info(VP8_COMP * cpi,MACROBLOCKD * xd,int * dissim,int * parent_ref_frame,MB_PREDICTION_MODE * parent_mode,int_mv * parent_ref_mv,int mb_row,int mb_col)409 void get_lower_res_motion_info(VP8_COMP *cpi, MACROBLOCKD *xd, int *dissim,
410                                int *parent_ref_frame,
411                                MB_PREDICTION_MODE *parent_mode,
412                                int_mv *parent_ref_mv, int mb_row, int mb_col)
413 {
414     LOWER_RES_MB_INFO* store_mode_info
415                           = ((LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info)->mb_info;
416     unsigned int parent_mb_index;
417 
418     /* Consider different down_sampling_factor.  */
419     {
420         /* TODO: Removed the loop that supports special down_sampling_factor
421          * such as 2, 4, 8. Will revisit it if needed.
422          * Should also try using a look-up table to see if it helps
423          * performance. */
424         int parent_mb_row, parent_mb_col;
425 
426         parent_mb_row = mb_row*cpi->oxcf.mr_down_sampling_factor.den
427                     /cpi->oxcf.mr_down_sampling_factor.num;
428         parent_mb_col = mb_col*cpi->oxcf.mr_down_sampling_factor.den
429                     /cpi->oxcf.mr_down_sampling_factor.num;
430         parent_mb_index = parent_mb_row*cpi->mr_low_res_mb_cols + parent_mb_col;
431     }
432 
433     /* Read lower-resolution mode & motion result from memory.*/
434     *parent_ref_frame = store_mode_info[parent_mb_index].ref_frame;
435     *parent_mode =  store_mode_info[parent_mb_index].mode;
436     *dissim = store_mode_info[parent_mb_index].dissim;
437 
438     /* For highest-resolution encoder, adjust dissim value. Lower its quality
439      * for good performance. */
440     if (cpi->oxcf.mr_encoder_id == (cpi->oxcf.mr_total_resolutions - 1))
441         *dissim>>=1;
442 
443     if(*parent_ref_frame != INTRA_FRAME)
444     {
445         /* Consider different down_sampling_factor.
446          * The result can be rounded to be more precise, but it takes more time.
447          */
448         (*parent_ref_mv).as_mv.row = store_mode_info[parent_mb_index].mv.as_mv.row
449                                   *cpi->oxcf.mr_down_sampling_factor.num
450                                   /cpi->oxcf.mr_down_sampling_factor.den;
451         (*parent_ref_mv).as_mv.col = store_mode_info[parent_mb_index].mv.as_mv.col
452                                   *cpi->oxcf.mr_down_sampling_factor.num
453                                   /cpi->oxcf.mr_down_sampling_factor.den;
454 
455         vp8_clamp_mv2(parent_ref_mv, xd);
456     }
457 }
458 #endif
459 
check_for_encode_breakout(unsigned int sse,MACROBLOCK * x)460 static void check_for_encode_breakout(unsigned int sse, MACROBLOCK* x)
461 {
462     MACROBLOCKD *xd = &x->e_mbd;
463 
464     unsigned int threshold = (xd->block[0].dequant[1]
465         * xd->block[0].dequant[1] >>4);
466 
467     if(threshold < x->encode_breakout)
468         threshold = x->encode_breakout;
469 
470     if (sse < threshold )
471     {
472         /* Check u and v to make sure skip is ok */
473         unsigned int sse2 = 0;
474 
475         sse2 = VP8_UVSSE(x);
476 
477         if (sse2 * 2 < x->encode_breakout)
478             x->skip = 1;
479         else
480             x->skip = 0;
481     }
482 }
483 
evaluate_inter_mode(unsigned int * sse,int rate2,int * distortion2,VP8_COMP * cpi,MACROBLOCK * x,int rd_adj)484 static int evaluate_inter_mode(unsigned int* sse, int rate2, int* distortion2,
485                                VP8_COMP *cpi, MACROBLOCK *x, int rd_adj)
486 {
487     MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode;
488     int_mv mv = x->e_mbd.mode_info_context->mbmi.mv;
489     int this_rd;
490     /* Exit early and don't compute the distortion if this macroblock
491      * is marked inactive. */
492     if (cpi->active_map_enabled && x->active_ptr[0] == 0)
493     {
494         *sse = 0;
495         *distortion2 = 0;
496         x->skip = 1;
497         return INT_MAX;
498     }
499 
500     if((this_mode != NEWMV) ||
501         !(cpi->sf.half_pixel_search) || cpi->common.full_pixel==1)
502         *distortion2 = vp8_get_inter_mbpred_error(x,
503                                               &cpi->fn_ptr[BLOCK_16X16],
504                                               sse, mv);
505 
506     this_rd = RDCOST(x->rdmult, x->rddiv, rate2, *distortion2);
507 
508     /* Adjust rd to bias to ZEROMV */
509     if(this_mode == ZEROMV)
510     {
511         /* Bias to ZEROMV on LAST_FRAME reference when it is available. */
512         if ((cpi->ref_frame_flags & VP8_LAST_FRAME &
513             cpi->common.refresh_last_frame)
514             && x->e_mbd.mode_info_context->mbmi.ref_frame != LAST_FRAME)
515             rd_adj = 100;
516 
517         // rd_adj <= 100
518         this_rd = ((int64_t)this_rd) * rd_adj / 100;
519     }
520 
521     check_for_encode_breakout(*sse, x);
522     return this_rd;
523 }
524 
calculate_zeromv_rd_adjustment(VP8_COMP * cpi,MACROBLOCK * x,int * rd_adjustment)525 static void calculate_zeromv_rd_adjustment(VP8_COMP *cpi, MACROBLOCK *x,
526                                     int *rd_adjustment)
527 {
528     MODE_INFO *mic = x->e_mbd.mode_info_context;
529     int_mv mv_l, mv_a, mv_al;
530     int local_motion_check = 0;
531 
532     if (cpi->lf_zeromv_pct > 40)
533     {
534         /* left mb */
535         mic -= 1;
536         mv_l = mic->mbmi.mv;
537 
538         if (mic->mbmi.ref_frame != INTRA_FRAME)
539             if( abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8)
540                 local_motion_check++;
541 
542         /* above-left mb */
543         mic -= x->e_mbd.mode_info_stride;
544         mv_al = mic->mbmi.mv;
545 
546         if (mic->mbmi.ref_frame != INTRA_FRAME)
547             if( abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8)
548                 local_motion_check++;
549 
550         /* above mb */
551         mic += 1;
552         mv_a = mic->mbmi.mv;
553 
554         if (mic->mbmi.ref_frame != INTRA_FRAME)
555             if( abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8)
556                 local_motion_check++;
557 
558         if (((!x->e_mbd.mb_to_top_edge || !x->e_mbd.mb_to_left_edge)
559             && local_motion_check >0) ||  local_motion_check >2 )
560             *rd_adjustment = 80;
561         else if (local_motion_check > 0)
562             *rd_adjustment = 90;
563     }
564 }
565 
vp8_pick_inter_mode(VP8_COMP * cpi,MACROBLOCK * x,int recon_yoffset,int recon_uvoffset,int * returnrate,int * returndistortion,int * returnintra,int mb_row,int mb_col)566 void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset,
567                          int recon_uvoffset, int *returnrate,
568                          int *returndistortion, int *returnintra, int mb_row,
569                          int mb_col)
570 {
571     BLOCK *b = &x->block[0];
572     BLOCKD *d = &x->e_mbd.block[0];
573     MACROBLOCKD *xd = &x->e_mbd;
574     MB_MODE_INFO best_mbmode;
575 
576     int_mv best_ref_mv_sb[2];
577     int_mv mode_mv_sb[2][MB_MODE_COUNT];
578     int_mv best_ref_mv;
579     int_mv *mode_mv;
580     MB_PREDICTION_MODE this_mode;
581     int num00;
582     int mdcounts[4];
583     int best_rd = INT_MAX;
584     int rd_adjustment = 100;
585     int best_intra_rd = INT_MAX;
586     int mode_index;
587     int rate;
588     int rate2;
589     int distortion2;
590     int bestsme = INT_MAX;
591     int best_mode_index = 0;
592     unsigned int sse = UINT_MAX, best_rd_sse = UINT_MAX;
593 #if CONFIG_TEMPORAL_DENOISING
594     unsigned int zero_mv_sse = UINT_MAX, best_sse = UINT_MAX;
595 #endif
596 
597     int sf_improved_mv_pred = cpi->sf.improved_mv_pred;
598     int_mv mvp;
599 
600     int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
601     int saddone=0;
602     /* search range got from mv_pred(). It uses step_param levels. (0-7) */
603     int sr=0;
604 
605     unsigned char *plane[4][3];
606     int ref_frame_map[4];
607     int sign_bias = 0;
608 
609 #if CONFIG_MULTI_RES_ENCODING
610     int dissim = INT_MAX;
611     int parent_ref_frame = 0;
612     int parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail;
613     int_mv parent_ref_mv;
614     MB_PREDICTION_MODE parent_mode = 0;
615 
616     if (parent_ref_valid)
617     {
618         int parent_ref_flag;
619 
620         get_lower_res_motion_info(cpi, xd, &dissim, &parent_ref_frame,
621                                   &parent_mode, &parent_ref_mv, mb_row, mb_col);
622 
623         /* TODO(jkoleszar): The references available (ref_frame_flags) to the
624          * lower res encoder should match those available to this encoder, but
625          * there seems to be a situation where this mismatch can happen in the
626          * case of frame dropping and temporal layers. For example,
627          * GOLD being disallowed in ref_frame_flags, but being returned as
628          * parent_ref_frame.
629          *
630          * In this event, take the conservative approach of disabling the
631          * lower res info for this MB.
632          */
633         parent_ref_flag = 0;
634         if (parent_ref_frame == LAST_FRAME)
635             parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME);
636         else if (parent_ref_frame == GOLDEN_FRAME)
637             parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME);
638         else if (parent_ref_frame == ALTREF_FRAME)
639             parent_ref_flag = (cpi->ref_frame_flags & VP8_ALTR_FRAME);
640 
641         //assert(!parent_ref_frame || parent_ref_flag);
642         if (parent_ref_frame && !parent_ref_flag)
643             parent_ref_valid = 0;
644     }
645 #endif
646 
647     mode_mv = mode_mv_sb[sign_bias];
648     best_ref_mv.as_int = 0;
649     vpx_memset(mode_mv_sb, 0, sizeof(mode_mv_sb));
650     vpx_memset(&best_mbmode, 0, sizeof(best_mbmode));
651 
652     /* Setup search priorities */
653 #if CONFIG_MULTI_RES_ENCODING
654     if (parent_ref_valid && parent_ref_frame && dissim < 8)
655     {
656         ref_frame_map[0] = -1;
657         ref_frame_map[1] = parent_ref_frame;
658         ref_frame_map[2] = -1;
659         ref_frame_map[3] = -1;
660     } else
661 #endif
662     get_reference_search_order(cpi, ref_frame_map);
663 
664     /* Check to see if there is at least 1 valid reference frame that we need
665      * to calculate near_mvs.
666      */
667     if (ref_frame_map[1] > 0)
668     {
669         sign_bias = vp8_find_near_mvs_bias(&x->e_mbd,
670                                            x->e_mbd.mode_info_context,
671                                            mode_mv_sb,
672                                            best_ref_mv_sb,
673                                            mdcounts,
674                                            ref_frame_map[1],
675                                            cpi->common.ref_frame_sign_bias);
676 
677         mode_mv = mode_mv_sb[sign_bias];
678         best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
679     }
680 
681     get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset);
682 
683     /* Count of the number of MBs tested so far this frame */
684     x->mbs_tested_so_far++;
685 
686     *returnintra = INT_MAX;
687     x->skip = 0;
688 
689     x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
690 
691     /* If the frame has big static background and current MB is in low
692      * motion area, its mode decision is biased to ZEROMV mode.
693      */
694     calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment);
695 
696 #if CONFIG_TEMPORAL_DENOISING
697     if (cpi->oxcf.noise_sensitivity) {
698       rd_adjustment = (int)(rd_adjustment *
699           cpi->denoiser.denoise_pars.pickmode_mv_bias / 100);
700     }
701 #endif
702 
703     /* if we encode a new mv this is important
704      * find the best new motion vector
705      */
706     for (mode_index = 0; mode_index < MAX_MODES; mode_index++)
707     {
708         int frame_cost;
709         int this_rd = INT_MAX;
710         int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]];
711 
712         if (best_rd <= x->rd_threshes[mode_index])
713             continue;
714 
715         if (this_ref_frame < 0)
716             continue;
717 
718         x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
719 
720         /* everything but intra */
721         if (x->e_mbd.mode_info_context->mbmi.ref_frame)
722         {
723             x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
724             x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
725             x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
726 
727             if (sign_bias != cpi->common.ref_frame_sign_bias[this_ref_frame])
728             {
729                 sign_bias = cpi->common.ref_frame_sign_bias[this_ref_frame];
730                 mode_mv = mode_mv_sb[sign_bias];
731                 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
732             }
733 
734 #if CONFIG_MULTI_RES_ENCODING
735             if (parent_ref_valid)
736             {
737                 if (vp8_mode_order[mode_index] == NEARESTMV &&
738                     mode_mv[NEARESTMV].as_int ==0)
739                     continue;
740                 if (vp8_mode_order[mode_index] == NEARMV &&
741                     mode_mv[NEARMV].as_int ==0)
742                     continue;
743 
744                 if (vp8_mode_order[mode_index] == NEWMV && parent_mode == ZEROMV
745                     && best_ref_mv.as_int==0)
746                     continue;
747                 else if(vp8_mode_order[mode_index] == NEWMV && dissim==0
748                     && best_ref_mv.as_int==parent_ref_mv.as_int)
749                     continue;
750             }
751 #endif
752         }
753 
754         /* Check to see if the testing frequency for this mode is at its max
755          * If so then prevent it from being tested and increase the threshold
756          * for its testing */
757         if (x->mode_test_hit_counts[mode_index] &&
758                                          (cpi->mode_check_freq[mode_index] > 1))
759         {
760             if (x->mbs_tested_so_far <= (cpi->mode_check_freq[mode_index] *
761                                          x->mode_test_hit_counts[mode_index]))
762             {
763                 /* Increase the threshold for coding this mode to make it less
764                  * likely to be chosen */
765                 x->rd_thresh_mult[mode_index] += 4;
766 
767                 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
768                     x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
769 
770                 x->rd_threshes[mode_index] =
771                                  (cpi->rd_baseline_thresh[mode_index] >> 7) *
772                                  x->rd_thresh_mult[mode_index];
773                 continue;
774             }
775         }
776 
777         /* We have now reached the point where we are going to test the current
778          * mode so increment the counter for the number of times it has been
779          * tested */
780         x->mode_test_hit_counts[mode_index] ++;
781 
782         rate2 = 0;
783         distortion2 = 0;
784 
785         this_mode = vp8_mode_order[mode_index];
786 
787         x->e_mbd.mode_info_context->mbmi.mode = this_mode;
788         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
789 
790         /* Work out the cost assosciated with selecting the reference frame */
791         frame_cost =
792             x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
793         rate2 += frame_cost;
794 
795         /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
796          * unless ARNR filtering is enabled in which case we want
797          * an unfiltered alternative */
798         if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
799         {
800             if (this_mode != ZEROMV ||
801                 x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
802                 continue;
803         }
804 
805         switch (this_mode)
806         {
807         case B_PRED:
808             /* Pass best so far to pick_intra4x4mby_modes to use as breakout */
809             distortion2 = best_rd_sse;
810             pick_intra4x4mby_modes(x, &rate, &distortion2);
811 
812             if (distortion2 == INT_MAX)
813             {
814                 this_rd = INT_MAX;
815             }
816             else
817             {
818                 rate2 += rate;
819                 distortion2 = vp8_variance16x16(
820                                     *(b->base_src), b->src_stride,
821                                     x->e_mbd.predictor, 16, &sse);
822                 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
823 
824                 if (this_rd < best_intra_rd)
825                 {
826                     best_intra_rd = this_rd;
827                     *returnintra = distortion2;
828                 }
829             }
830 
831             break;
832 
833         case SPLITMV:
834 
835             /* Split MV modes currently not supported when RD is not enabled. */
836             break;
837 
838         case DC_PRED:
839         case V_PRED:
840         case H_PRED:
841         case TM_PRED:
842             vp8_build_intra_predictors_mby_s(xd,
843                                              xd->dst.y_buffer - xd->dst.y_stride,
844                                              xd->dst.y_buffer - 1,
845                                              xd->dst.y_stride,
846                                              xd->predictor,
847                                              16);
848             distortion2 = vp8_variance16x16
849                                           (*(b->base_src), b->src_stride,
850                                           x->e_mbd.predictor, 16, &sse);
851             rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
852             this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
853 
854             if (this_rd < best_intra_rd)
855             {
856                 best_intra_rd = this_rd;
857                 *returnintra = distortion2;
858             }
859             break;
860 
861         case NEWMV:
862         {
863             int thissme;
864             int step_param;
865             int further_steps;
866             int n = 0;
867             int sadpb = x->sadperbit16;
868             int_mv mvp_full;
869 
870             int col_min = ((best_ref_mv.as_mv.col+7)>>3) - MAX_FULL_PEL_VAL;
871             int row_min = ((best_ref_mv.as_mv.row+7)>>3) - MAX_FULL_PEL_VAL;
872             int col_max = (best_ref_mv.as_mv.col>>3)
873                          + MAX_FULL_PEL_VAL;
874             int row_max = (best_ref_mv.as_mv.row>>3)
875                          + MAX_FULL_PEL_VAL;
876 
877             int tmp_col_min = x->mv_col_min;
878             int tmp_col_max = x->mv_col_max;
879             int tmp_row_min = x->mv_row_min;
880             int tmp_row_max = x->mv_row_max;
881 
882             int speed_adjust = (cpi->Speed > 5) ? ((cpi->Speed >= 8)? 3 : 2) : 1;
883 
884             /* Further step/diamond searches as necessary */
885             step_param = cpi->sf.first_step + speed_adjust;
886 
887 #if CONFIG_MULTI_RES_ENCODING
888             /* If lower-res drops this frame, then higher-res encoder does
889                motion search without any previous knowledge. Also, since
890                last frame motion info is not stored, then we can not
891                use improved_mv_pred. */
892             if (cpi->oxcf.mr_encoder_id && !parent_ref_valid)
893                 sf_improved_mv_pred = 0;
894 
895             if (parent_ref_valid && parent_ref_frame)
896             {
897                 /* Use parent MV as predictor. Adjust search range
898                  * accordingly.
899                  */
900                 mvp.as_int = parent_ref_mv.as_int;
901                 mvp_full.as_mv.col = parent_ref_mv.as_mv.col>>3;
902                 mvp_full.as_mv.row = parent_ref_mv.as_mv.row>>3;
903 
904                 if(dissim <=32) step_param += 3;
905                 else if(dissim <=128) step_param += 2;
906                 else step_param += 1;
907             }else
908 #endif
909             {
910                 if(sf_improved_mv_pred)
911                 {
912                     if(!saddone)
913                     {
914                         vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] );
915                         saddone = 1;
916                     }
917 
918                     vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context,
919                                 &mvp,x->e_mbd.mode_info_context->mbmi.ref_frame,
920                                 cpi->common.ref_frame_sign_bias, &sr,
921                                 &near_sadidx[0]);
922 
923                     sr += speed_adjust;
924                     /* adjust search range according to sr from mv prediction */
925                     if(sr > step_param)
926                         step_param = sr;
927 
928                     mvp_full.as_mv.col = mvp.as_mv.col>>3;
929                     mvp_full.as_mv.row = mvp.as_mv.row>>3;
930                 }else
931                 {
932                     mvp.as_int = best_ref_mv.as_int;
933                     mvp_full.as_mv.col = best_ref_mv.as_mv.col>>3;
934                     mvp_full.as_mv.row = best_ref_mv.as_mv.row>>3;
935                 }
936             }
937 
938 #if CONFIG_MULTI_RES_ENCODING
939             if (parent_ref_valid && parent_ref_frame && dissim <= 2 &&
940                 MAX(abs(best_ref_mv.as_mv.row - parent_ref_mv.as_mv.row),
941                     abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4)
942             {
943                 d->bmi.mv.as_int = mvp_full.as_int;
944                 mode_mv[NEWMV].as_int = mvp_full.as_int;
945 
946                 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv,
947                                              x->errorperbit,
948                                              &cpi->fn_ptr[BLOCK_16X16],
949                                              cpi->mb.mvcost,
950                                              &distortion2,&sse);
951             }else
952 #endif
953             {
954                 /* Get intersection of UMV window and valid MV window to
955                  * reduce # of checks in diamond search. */
956                 if (x->mv_col_min < col_min )
957                     x->mv_col_min = col_min;
958                 if (x->mv_col_max > col_max )
959                     x->mv_col_max = col_max;
960                 if (x->mv_row_min < row_min )
961                     x->mv_row_min = row_min;
962                 if (x->mv_row_max > row_max )
963                     x->mv_row_max = row_max;
964 
965                 further_steps = (cpi->Speed >= 8)?
966                            0: (cpi->sf.max_step_search_steps - 1 - step_param);
967 
968                 if (cpi->sf.search_method == HEX)
969                 {
970 #if CONFIG_MULTI_RES_ENCODING
971                 /* TODO: In higher-res pick_inter_mode, step_param is used to
972                  * modify hex search range. Here, set step_param to 0 not to
973                  * change the behavior in lowest-resolution encoder.
974                  * Will improve it later.
975                  */
976                  /* Set step_param to 0 to ensure large-range motion search
977                     when encoder drops this frame at lower-resolution.
978                   */
979                 if (!parent_ref_valid)
980                     step_param = 0;
981 #endif
982                     bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv,
983                                           step_param, sadpb,
984                                           &cpi->fn_ptr[BLOCK_16X16],
985                                           x->mvsadcost, x->mvcost, &best_ref_mv);
986                     mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
987                 }
988                 else
989                 {
990                     bestsme = cpi->diamond_search_sad(x, b, d, &mvp_full,
991                                           &d->bmi.mv, step_param, sadpb, &num00,
992                                           &cpi->fn_ptr[BLOCK_16X16],
993                                           x->mvcost, &best_ref_mv);
994                     mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
995 
996                     /* Further step/diamond searches as necessary */
997                     n = num00;
998                     num00 = 0;
999 
1000                     while (n < further_steps)
1001                     {
1002                         n++;
1003 
1004                         if (num00)
1005                             num00--;
1006                         else
1007                         {
1008                             thissme =
1009                             cpi->diamond_search_sad(x, b, d, &mvp_full,
1010                                                     &d->bmi.mv,
1011                                                     step_param + n,
1012                                                     sadpb, &num00,
1013                                                     &cpi->fn_ptr[BLOCK_16X16],
1014                                                     x->mvcost, &best_ref_mv);
1015                             if (thissme < bestsme)
1016                             {
1017                                 bestsme = thissme;
1018                                 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
1019                             }
1020                             else
1021                             {
1022                                 d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
1023                             }
1024                         }
1025                     }
1026                 }
1027 
1028                 x->mv_col_min = tmp_col_min;
1029                 x->mv_col_max = tmp_col_max;
1030                 x->mv_row_min = tmp_row_min;
1031                 x->mv_row_max = tmp_row_max;
1032 
1033                 if (bestsme < INT_MAX)
1034                     cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv,
1035                                              &best_ref_mv, x->errorperbit,
1036                                              &cpi->fn_ptr[BLOCK_16X16],
1037                                              cpi->mb.mvcost,
1038                                              &distortion2,&sse);
1039             }
1040 
1041             mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
1042 
1043             /* mv cost; */
1044             rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv,
1045                                      cpi->mb.mvcost, 128);
1046         }
1047 
1048         case NEARESTMV:
1049         case NEARMV:
1050 
1051             if (mode_mv[this_mode].as_int == 0)
1052                 continue;
1053 
1054         case ZEROMV:
1055 
1056             /* Trap vectors that reach beyond the UMV borders
1057              * Note that ALL New MV, Nearest MV Near MV and Zero MV code drops
1058              * through to this point because of the lack of break statements
1059              * in the previous two cases.
1060              */
1061             if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
1062                 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
1063                 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
1064                 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
1065                 continue;
1066 
1067             rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
1068             x->e_mbd.mode_info_context->mbmi.mv.as_int =
1069                                                     mode_mv[this_mode].as_int;
1070             this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x,
1071                                           rd_adjustment);
1072 
1073             break;
1074         default:
1075             break;
1076         }
1077 
1078 #if CONFIG_TEMPORAL_DENOISING
1079         if (cpi->oxcf.noise_sensitivity)
1080         {
1081 
1082             /* Store for later use by denoiser. */
1083             if (this_mode == ZEROMV && sse < zero_mv_sse )
1084             {
1085                 zero_mv_sse = sse;
1086                 x->best_zeromv_reference_frame =
1087                         x->e_mbd.mode_info_context->mbmi.ref_frame;
1088             }
1089 
1090             /* Store the best NEWMV in x for later use in the denoiser. */
1091             if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV &&
1092                     sse < best_sse)
1093             {
1094                 best_sse = sse;
1095                 x->best_sse_inter_mode = NEWMV;
1096                 x->best_sse_mv = x->e_mbd.mode_info_context->mbmi.mv;
1097                 x->need_to_clamp_best_mvs =
1098                     x->e_mbd.mode_info_context->mbmi.need_to_clamp_mvs;
1099                 x->best_reference_frame =
1100                     x->e_mbd.mode_info_context->mbmi.ref_frame;
1101             }
1102         }
1103 #endif
1104 
1105         if (this_rd < best_rd || x->skip)
1106         {
1107             /* Note index of best mode */
1108             best_mode_index = mode_index;
1109 
1110             *returnrate = rate2;
1111             *returndistortion = distortion2;
1112             best_rd_sse = sse;
1113             best_rd = this_rd;
1114             vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
1115                        sizeof(MB_MODE_INFO));
1116 
1117             /* Testing this mode gave rise to an improvement in best error
1118              * score. Lower threshold a bit for next time
1119              */
1120             x->rd_thresh_mult[mode_index] =
1121                      (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ?
1122                      x->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT;
1123             x->rd_threshes[mode_index] =
1124                                    (cpi->rd_baseline_thresh[mode_index] >> 7) *
1125                                    x->rd_thresh_mult[mode_index];
1126         }
1127 
1128         /* If the mode did not help improve the best error case then raise the
1129          * threshold for testing that mode next time around.
1130          */
1131         else
1132         {
1133             x->rd_thresh_mult[mode_index] += 4;
1134 
1135             if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
1136                 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1137 
1138             x->rd_threshes[mode_index] =
1139                          (cpi->rd_baseline_thresh[mode_index] >> 7) *
1140                          x->rd_thresh_mult[mode_index];
1141         }
1142 
1143         if (x->skip)
1144             break;
1145     }
1146 
1147     /* Reduce the activation RD thresholds for the best choice mode */
1148     if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2)))
1149     {
1150         int best_adjustment = (x->rd_thresh_mult[best_mode_index] >> 3);
1151 
1152         x->rd_thresh_mult[best_mode_index] =
1153                         (x->rd_thresh_mult[best_mode_index]
1154                         >= (MIN_THRESHMULT + best_adjustment)) ?
1155                         x->rd_thresh_mult[best_mode_index] - best_adjustment :
1156                         MIN_THRESHMULT;
1157         x->rd_threshes[best_mode_index] =
1158                         (cpi->rd_baseline_thresh[best_mode_index] >> 7) *
1159                         x->rd_thresh_mult[best_mode_index];
1160     }
1161 
1162 
1163     {
1164         int this_rdbin = (*returndistortion >> 7);
1165 
1166         if (this_rdbin >= 1024)
1167         {
1168             this_rdbin = 1023;
1169         }
1170 
1171         x->error_bins[this_rdbin] ++;
1172     }
1173 
1174 #if CONFIG_TEMPORAL_DENOISING
1175     if (cpi->oxcf.noise_sensitivity)
1176     {
1177         int block_index = mb_row * cpi->common.mb_cols + mb_col;
1178         if (x->best_sse_inter_mode == DC_PRED)
1179         {
1180             /* No best MV found. */
1181             x->best_sse_inter_mode = best_mbmode.mode;
1182             x->best_sse_mv = best_mbmode.mv;
1183             x->need_to_clamp_best_mvs = best_mbmode.need_to_clamp_mvs;
1184             x->best_reference_frame = best_mbmode.ref_frame;
1185             best_sse = best_rd_sse;
1186         }
1187         x->increase_denoising = 0;
1188         vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse,
1189                                 recon_yoffset, recon_uvoffset,
1190                                 &cpi->common.lf_info, mb_row, mb_col,
1191                                 block_index);
1192 
1193         /* Reevaluate ZEROMV after denoising. */
1194         if (best_mbmode.ref_frame == INTRA_FRAME &&
1195             x->best_zeromv_reference_frame != INTRA_FRAME)
1196         {
1197             int this_rd = 0;
1198             int this_ref_frame = x->best_zeromv_reference_frame;
1199             rate2 = x->ref_frame_cost[this_ref_frame] +
1200                     vp8_cost_mv_ref(ZEROMV, mdcounts);
1201             distortion2 = 0;
1202 
1203             /* set up the proper prediction buffers for the frame */
1204             x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
1205             x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
1206             x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
1207             x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
1208 
1209             x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
1210             x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1211             x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
1212             this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x,
1213                                           rd_adjustment);
1214 
1215             if (this_rd < best_rd)
1216             {
1217                 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
1218                            sizeof(MB_MODE_INFO));
1219             }
1220         }
1221 
1222     }
1223 #endif
1224 
1225     if (cpi->is_src_frame_alt_ref &&
1226         (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME))
1227     {
1228         x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
1229         x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME;
1230         x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
1231         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1232         x->e_mbd.mode_info_context->mbmi.mb_skip_coeff =
1233                                         (cpi->common.mb_no_coeff_skip);
1234         x->e_mbd.mode_info_context->mbmi.partitioning = 0;
1235 
1236         return;
1237     }
1238 
1239     /* set to the best mb mode, this copy can be skip if x->skip since it
1240      * already has the right content */
1241     if (!x->skip)
1242         vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode,
1243                    sizeof(MB_MODE_INFO));
1244 
1245     if (best_mbmode.mode <= B_PRED)
1246     {
1247         /* set mode_info_context->mbmi.uv_mode */
1248         pick_intra_mbuv_mode(x);
1249     }
1250 
1251     if (sign_bias
1252       != cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame])
1253         best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
1254 
1255     update_mvcount(x, &best_ref_mv);
1256 }
1257 
1258 
vp8_pick_intra_mode(MACROBLOCK * x,int * rate_)1259 void vp8_pick_intra_mode(MACROBLOCK *x, int *rate_)
1260 {
1261     int error4x4, error16x16 = INT_MAX;
1262     int rate, best_rate = 0, distortion, best_sse;
1263     MB_PREDICTION_MODE mode, best_mode = DC_PRED;
1264     int this_rd;
1265     unsigned int sse;
1266     BLOCK *b = &x->block[0];
1267     MACROBLOCKD *xd = &x->e_mbd;
1268 
1269     xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1270 
1271     pick_intra_mbuv_mode(x);
1272 
1273     for (mode = DC_PRED; mode <= TM_PRED; mode ++)
1274     {
1275         xd->mode_info_context->mbmi.mode = mode;
1276         vp8_build_intra_predictors_mby_s(xd,
1277                                          xd->dst.y_buffer - xd->dst.y_stride,
1278                                          xd->dst.y_buffer - 1,
1279                                          xd->dst.y_stride,
1280                                          xd->predictor,
1281                                          16);
1282         distortion = vp8_variance16x16
1283             (*(b->base_src), b->src_stride, xd->predictor, 16, &sse);
1284         rate = x->mbmode_cost[xd->frame_type][mode];
1285         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1286 
1287         if (error16x16 > this_rd)
1288         {
1289             error16x16 = this_rd;
1290             best_mode = mode;
1291             best_sse = sse;
1292             best_rate = rate;
1293         }
1294     }
1295     xd->mode_info_context->mbmi.mode = best_mode;
1296 
1297     error4x4 = pick_intra4x4mby_modes(x, &rate,
1298                                       &best_sse);
1299     if (error4x4 < error16x16)
1300     {
1301         xd->mode_info_context->mbmi.mode = B_PRED;
1302         best_rate = rate;
1303     }
1304 
1305     *rate_ = best_rate;
1306 }
1307