• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     int denoise_aggressive = 0;
491     /* Exit early and don't compute the distortion if this macroblock
492      * is marked inactive. */
493     if (cpi->active_map_enabled && x->active_ptr[0] == 0)
494     {
495         *sse = 0;
496         *distortion2 = 0;
497         x->skip = 1;
498         return INT_MAX;
499     }
500 
501     if((this_mode != NEWMV) ||
502         !(cpi->sf.half_pixel_search) || cpi->common.full_pixel==1)
503         *distortion2 = vp8_get_inter_mbpred_error(x,
504                                               &cpi->fn_ptr[BLOCK_16X16],
505                                               sse, mv);
506 
507     this_rd = RDCOST(x->rdmult, x->rddiv, rate2, *distortion2);
508 
509 #if CONFIG_TEMPORAL_DENOISING
510     if (cpi->oxcf.noise_sensitivity > 0) {
511       denoise_aggressive =
512         (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive) ? 1 : 0;
513     }
514 #endif
515 
516     // Adjust rd for ZEROMV and LAST, if LAST is the closest reference frame.
517     if (this_mode == ZEROMV &&
518         x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME &&
519         (denoise_aggressive || cpi->closest_reference_frame == LAST_FRAME))
520     {
521         this_rd = ((int64_t)this_rd) * rd_adj / 100;
522     }
523 
524     check_for_encode_breakout(*sse, x);
525     return this_rd;
526 }
527 
calculate_zeromv_rd_adjustment(VP8_COMP * cpi,MACROBLOCK * x,int * rd_adjustment)528 static void calculate_zeromv_rd_adjustment(VP8_COMP *cpi, MACROBLOCK *x,
529                                     int *rd_adjustment)
530 {
531     MODE_INFO *mic = x->e_mbd.mode_info_context;
532     int_mv mv_l, mv_a, mv_al;
533     int local_motion_check = 0;
534 
535     if (cpi->lf_zeromv_pct > 40)
536     {
537         /* left mb */
538         mic -= 1;
539         mv_l = mic->mbmi.mv;
540 
541         if (mic->mbmi.ref_frame != INTRA_FRAME)
542             if( abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8)
543                 local_motion_check++;
544 
545         /* above-left mb */
546         mic -= x->e_mbd.mode_info_stride;
547         mv_al = mic->mbmi.mv;
548 
549         if (mic->mbmi.ref_frame != INTRA_FRAME)
550             if( abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8)
551                 local_motion_check++;
552 
553         /* above mb */
554         mic += 1;
555         mv_a = mic->mbmi.mv;
556 
557         if (mic->mbmi.ref_frame != INTRA_FRAME)
558             if( abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8)
559                 local_motion_check++;
560 
561         if (((!x->e_mbd.mb_to_top_edge || !x->e_mbd.mb_to_left_edge)
562             && local_motion_check >0) ||  local_motion_check >2 )
563             *rd_adjustment = 80;
564         else if (local_motion_check > 0)
565             *rd_adjustment = 90;
566     }
567 }
568 
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)569 void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset,
570                          int recon_uvoffset, int *returnrate,
571                          int *returndistortion, int *returnintra, int mb_row,
572                          int mb_col)
573 {
574     BLOCK *b = &x->block[0];
575     BLOCKD *d = &x->e_mbd.block[0];
576     MACROBLOCKD *xd = &x->e_mbd;
577     MB_MODE_INFO best_mbmode;
578 
579     int_mv best_ref_mv_sb[2];
580     int_mv mode_mv_sb[2][MB_MODE_COUNT];
581     int_mv best_ref_mv;
582     int_mv *mode_mv;
583     MB_PREDICTION_MODE this_mode;
584     int num00;
585     int mdcounts[4];
586     int best_rd = INT_MAX;
587     int rd_adjustment = 100;
588     int best_intra_rd = INT_MAX;
589     int mode_index;
590     int rate;
591     int rate2;
592     int distortion2;
593     int bestsme = INT_MAX;
594     int best_mode_index = 0;
595     unsigned int sse = UINT_MAX, best_rd_sse = UINT_MAX;
596 #if CONFIG_TEMPORAL_DENOISING
597     unsigned int zero_mv_sse = UINT_MAX, best_sse = UINT_MAX;
598 #endif
599 
600     int sf_improved_mv_pred = cpi->sf.improved_mv_pred;
601     int_mv mvp;
602 
603     int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
604     int saddone=0;
605     /* search range got from mv_pred(). It uses step_param levels. (0-7) */
606     int sr=0;
607 
608     unsigned char *plane[4][3];
609     int ref_frame_map[4];
610     int sign_bias = 0;
611 
612 #if CONFIG_MULTI_RES_ENCODING
613     int dissim = INT_MAX;
614     int parent_ref_frame = 0;
615     int parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail;
616     int_mv parent_ref_mv;
617     MB_PREDICTION_MODE parent_mode = 0;
618 
619     if (parent_ref_valid)
620     {
621         int parent_ref_flag;
622 
623         get_lower_res_motion_info(cpi, xd, &dissim, &parent_ref_frame,
624                                   &parent_mode, &parent_ref_mv, mb_row, mb_col);
625 
626         /* TODO(jkoleszar): The references available (ref_frame_flags) to the
627          * lower res encoder should match those available to this encoder, but
628          * there seems to be a situation where this mismatch can happen in the
629          * case of frame dropping and temporal layers. For example,
630          * GOLD being disallowed in ref_frame_flags, but being returned as
631          * parent_ref_frame.
632          *
633          * In this event, take the conservative approach of disabling the
634          * lower res info for this MB.
635          */
636         parent_ref_flag = 0;
637         if (parent_ref_frame == LAST_FRAME)
638             parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME);
639         else if (parent_ref_frame == GOLDEN_FRAME)
640             parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME);
641         else if (parent_ref_frame == ALTREF_FRAME)
642             parent_ref_flag = (cpi->ref_frame_flags & VP8_ALTR_FRAME);
643 
644         //assert(!parent_ref_frame || parent_ref_flag);
645         if (parent_ref_frame && !parent_ref_flag)
646             parent_ref_valid = 0;
647     }
648 #endif
649 
650     mode_mv = mode_mv_sb[sign_bias];
651     best_ref_mv.as_int = 0;
652     vpx_memset(mode_mv_sb, 0, sizeof(mode_mv_sb));
653     vpx_memset(&best_mbmode, 0, sizeof(best_mbmode));
654 
655     /* Setup search priorities */
656 #if CONFIG_MULTI_RES_ENCODING
657     if (parent_ref_valid && parent_ref_frame && dissim < 8)
658     {
659         ref_frame_map[0] = -1;
660         ref_frame_map[1] = parent_ref_frame;
661         ref_frame_map[2] = -1;
662         ref_frame_map[3] = -1;
663     } else
664 #endif
665     get_reference_search_order(cpi, ref_frame_map);
666 
667     /* Check to see if there is at least 1 valid reference frame that we need
668      * to calculate near_mvs.
669      */
670     if (ref_frame_map[1] > 0)
671     {
672         sign_bias = vp8_find_near_mvs_bias(&x->e_mbd,
673                                            x->e_mbd.mode_info_context,
674                                            mode_mv_sb,
675                                            best_ref_mv_sb,
676                                            mdcounts,
677                                            ref_frame_map[1],
678                                            cpi->common.ref_frame_sign_bias);
679 
680         mode_mv = mode_mv_sb[sign_bias];
681         best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
682     }
683 
684     get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset);
685 
686     /* Count of the number of MBs tested so far this frame */
687     x->mbs_tested_so_far++;
688 
689     *returnintra = INT_MAX;
690     x->skip = 0;
691 
692     x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
693 
694     /* If the frame has big static background and current MB is in low
695      * motion area, its mode decision is biased to ZEROMV mode.
696      */
697     calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment);
698 
699 #if CONFIG_TEMPORAL_DENOISING
700     if (cpi->oxcf.noise_sensitivity) {
701       rd_adjustment = (int)(rd_adjustment *
702           cpi->denoiser.denoise_pars.pickmode_mv_bias / 100);
703     }
704 #endif
705 
706     /* if we encode a new mv this is important
707      * find the best new motion vector
708      */
709     for (mode_index = 0; mode_index < MAX_MODES; mode_index++)
710     {
711         int frame_cost;
712         int this_rd = INT_MAX;
713         int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]];
714 
715         if (best_rd <= x->rd_threshes[mode_index])
716             continue;
717 
718         if (this_ref_frame < 0)
719             continue;
720 
721         x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
722 
723         /* everything but intra */
724         if (x->e_mbd.mode_info_context->mbmi.ref_frame)
725         {
726             x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
727             x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
728             x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
729 
730             if (sign_bias != cpi->common.ref_frame_sign_bias[this_ref_frame])
731             {
732                 sign_bias = cpi->common.ref_frame_sign_bias[this_ref_frame];
733                 mode_mv = mode_mv_sb[sign_bias];
734                 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
735             }
736 
737 #if CONFIG_MULTI_RES_ENCODING
738             if (parent_ref_valid)
739             {
740                 if (vp8_mode_order[mode_index] == NEARESTMV &&
741                     mode_mv[NEARESTMV].as_int ==0)
742                     continue;
743                 if (vp8_mode_order[mode_index] == NEARMV &&
744                     mode_mv[NEARMV].as_int ==0)
745                     continue;
746 
747                 if (vp8_mode_order[mode_index] == NEWMV && parent_mode == ZEROMV
748                     && best_ref_mv.as_int==0)
749                     continue;
750                 else if(vp8_mode_order[mode_index] == NEWMV && dissim==0
751                     && best_ref_mv.as_int==parent_ref_mv.as_int)
752                     continue;
753             }
754 #endif
755         }
756 
757         /* Check to see if the testing frequency for this mode is at its max
758          * If so then prevent it from being tested and increase the threshold
759          * for its testing */
760         if (x->mode_test_hit_counts[mode_index] &&
761                                          (cpi->mode_check_freq[mode_index] > 1))
762         {
763             if (x->mbs_tested_so_far <= (cpi->mode_check_freq[mode_index] *
764                                          x->mode_test_hit_counts[mode_index]))
765             {
766                 /* Increase the threshold for coding this mode to make it less
767                  * likely to be chosen */
768                 x->rd_thresh_mult[mode_index] += 4;
769 
770                 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
771                     x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
772 
773                 x->rd_threshes[mode_index] =
774                                  (cpi->rd_baseline_thresh[mode_index] >> 7) *
775                                  x->rd_thresh_mult[mode_index];
776                 continue;
777             }
778         }
779 
780         /* We have now reached the point where we are going to test the current
781          * mode so increment the counter for the number of times it has been
782          * tested */
783         x->mode_test_hit_counts[mode_index] ++;
784 
785         rate2 = 0;
786         distortion2 = 0;
787 
788         this_mode = vp8_mode_order[mode_index];
789 
790         x->e_mbd.mode_info_context->mbmi.mode = this_mode;
791         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
792 
793         /* Work out the cost assosciated with selecting the reference frame */
794         frame_cost =
795             x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
796         rate2 += frame_cost;
797 
798         /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
799          * unless ARNR filtering is enabled in which case we want
800          * an unfiltered alternative */
801         if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
802         {
803             if (this_mode != ZEROMV ||
804                 x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
805                 continue;
806         }
807 
808         switch (this_mode)
809         {
810         case B_PRED:
811             /* Pass best so far to pick_intra4x4mby_modes to use as breakout */
812             distortion2 = best_rd_sse;
813             pick_intra4x4mby_modes(x, &rate, &distortion2);
814 
815             if (distortion2 == INT_MAX)
816             {
817                 this_rd = INT_MAX;
818             }
819             else
820             {
821                 rate2 += rate;
822                 distortion2 = vp8_variance16x16(
823                                     *(b->base_src), b->src_stride,
824                                     x->e_mbd.predictor, 16, &sse);
825                 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
826 
827                 if (this_rd < best_intra_rd)
828                 {
829                     best_intra_rd = this_rd;
830                     *returnintra = distortion2;
831                 }
832             }
833 
834             break;
835 
836         case SPLITMV:
837 
838             /* Split MV modes currently not supported when RD is not enabled. */
839             break;
840 
841         case DC_PRED:
842         case V_PRED:
843         case H_PRED:
844         case TM_PRED:
845             vp8_build_intra_predictors_mby_s(xd,
846                                              xd->dst.y_buffer - xd->dst.y_stride,
847                                              xd->dst.y_buffer - 1,
848                                              xd->dst.y_stride,
849                                              xd->predictor,
850                                              16);
851             distortion2 = vp8_variance16x16
852                                           (*(b->base_src), b->src_stride,
853                                           x->e_mbd.predictor, 16, &sse);
854             rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
855             this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
856 
857             if (this_rd < best_intra_rd)
858             {
859                 best_intra_rd = this_rd;
860                 *returnintra = distortion2;
861             }
862             break;
863 
864         case NEWMV:
865         {
866             int thissme;
867             int step_param;
868             int further_steps;
869             int n = 0;
870             int sadpb = x->sadperbit16;
871             int_mv mvp_full;
872 
873             int col_min = ((best_ref_mv.as_mv.col+7)>>3) - MAX_FULL_PEL_VAL;
874             int row_min = ((best_ref_mv.as_mv.row+7)>>3) - MAX_FULL_PEL_VAL;
875             int col_max = (best_ref_mv.as_mv.col>>3)
876                          + MAX_FULL_PEL_VAL;
877             int row_max = (best_ref_mv.as_mv.row>>3)
878                          + MAX_FULL_PEL_VAL;
879 
880             int tmp_col_min = x->mv_col_min;
881             int tmp_col_max = x->mv_col_max;
882             int tmp_row_min = x->mv_row_min;
883             int tmp_row_max = x->mv_row_max;
884 
885             int speed_adjust = (cpi->Speed > 5) ? ((cpi->Speed >= 8)? 3 : 2) : 1;
886 
887             /* Further step/diamond searches as necessary */
888             step_param = cpi->sf.first_step + speed_adjust;
889 
890 #if CONFIG_MULTI_RES_ENCODING
891             /* If lower-res drops this frame, then higher-res encoder does
892                motion search without any previous knowledge. Also, since
893                last frame motion info is not stored, then we can not
894                use improved_mv_pred. */
895             if (cpi->oxcf.mr_encoder_id && !parent_ref_valid)
896                 sf_improved_mv_pred = 0;
897 
898             if (parent_ref_valid && parent_ref_frame)
899             {
900                 /* Use parent MV as predictor. Adjust search range
901                  * accordingly.
902                  */
903                 mvp.as_int = parent_ref_mv.as_int;
904                 mvp_full.as_mv.col = parent_ref_mv.as_mv.col>>3;
905                 mvp_full.as_mv.row = parent_ref_mv.as_mv.row>>3;
906 
907                 if(dissim <=32) step_param += 3;
908                 else if(dissim <=128) step_param += 2;
909                 else step_param += 1;
910             }else
911 #endif
912             {
913                 if(sf_improved_mv_pred)
914                 {
915                     if(!saddone)
916                     {
917                         vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] );
918                         saddone = 1;
919                     }
920 
921                     vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context,
922                                 &mvp,x->e_mbd.mode_info_context->mbmi.ref_frame,
923                                 cpi->common.ref_frame_sign_bias, &sr,
924                                 &near_sadidx[0]);
925 
926                     sr += speed_adjust;
927                     /* adjust search range according to sr from mv prediction */
928                     if(sr > step_param)
929                         step_param = sr;
930 
931                     mvp_full.as_mv.col = mvp.as_mv.col>>3;
932                     mvp_full.as_mv.row = mvp.as_mv.row>>3;
933                 }else
934                 {
935                     mvp.as_int = best_ref_mv.as_int;
936                     mvp_full.as_mv.col = best_ref_mv.as_mv.col>>3;
937                     mvp_full.as_mv.row = best_ref_mv.as_mv.row>>3;
938                 }
939             }
940 
941 #if CONFIG_MULTI_RES_ENCODING
942             if (parent_ref_valid && parent_ref_frame && dissim <= 2 &&
943                 MAX(abs(best_ref_mv.as_mv.row - parent_ref_mv.as_mv.row),
944                     abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4)
945             {
946                 d->bmi.mv.as_int = mvp_full.as_int;
947                 mode_mv[NEWMV].as_int = mvp_full.as_int;
948 
949                 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv,
950                                              x->errorperbit,
951                                              &cpi->fn_ptr[BLOCK_16X16],
952                                              cpi->mb.mvcost,
953                                              &distortion2,&sse);
954             }else
955 #endif
956             {
957                 /* Get intersection of UMV window and valid MV window to
958                  * reduce # of checks in diamond search. */
959                 if (x->mv_col_min < col_min )
960                     x->mv_col_min = col_min;
961                 if (x->mv_col_max > col_max )
962                     x->mv_col_max = col_max;
963                 if (x->mv_row_min < row_min )
964                     x->mv_row_min = row_min;
965                 if (x->mv_row_max > row_max )
966                     x->mv_row_max = row_max;
967 
968                 further_steps = (cpi->Speed >= 8)?
969                            0: (cpi->sf.max_step_search_steps - 1 - step_param);
970 
971                 if (cpi->sf.search_method == HEX)
972                 {
973 #if CONFIG_MULTI_RES_ENCODING
974                 /* TODO: In higher-res pick_inter_mode, step_param is used to
975                  * modify hex search range. Here, set step_param to 0 not to
976                  * change the behavior in lowest-resolution encoder.
977                  * Will improve it later.
978                  */
979                  /* Set step_param to 0 to ensure large-range motion search
980                     when encoder drops this frame at lower-resolution.
981                   */
982                 if (!parent_ref_valid)
983                     step_param = 0;
984 #endif
985                     bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv,
986                                           step_param, sadpb,
987                                           &cpi->fn_ptr[BLOCK_16X16],
988                                           x->mvsadcost, x->mvcost, &best_ref_mv);
989                     mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
990                 }
991                 else
992                 {
993                     bestsme = cpi->diamond_search_sad(x, b, d, &mvp_full,
994                                           &d->bmi.mv, step_param, sadpb, &num00,
995                                           &cpi->fn_ptr[BLOCK_16X16],
996                                           x->mvcost, &best_ref_mv);
997                     mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
998 
999                     /* Further step/diamond searches as necessary */
1000                     n = num00;
1001                     num00 = 0;
1002 
1003                     while (n < further_steps)
1004                     {
1005                         n++;
1006 
1007                         if (num00)
1008                             num00--;
1009                         else
1010                         {
1011                             thissme =
1012                             cpi->diamond_search_sad(x, b, d, &mvp_full,
1013                                                     &d->bmi.mv,
1014                                                     step_param + n,
1015                                                     sadpb, &num00,
1016                                                     &cpi->fn_ptr[BLOCK_16X16],
1017                                                     x->mvcost, &best_ref_mv);
1018                             if (thissme < bestsme)
1019                             {
1020                                 bestsme = thissme;
1021                                 mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
1022                             }
1023                             else
1024                             {
1025                                 d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
1026                             }
1027                         }
1028                     }
1029                 }
1030 
1031                 x->mv_col_min = tmp_col_min;
1032                 x->mv_col_max = tmp_col_max;
1033                 x->mv_row_min = tmp_row_min;
1034                 x->mv_row_max = tmp_row_max;
1035 
1036                 if (bestsme < INT_MAX)
1037                     cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv,
1038                                              &best_ref_mv, x->errorperbit,
1039                                              &cpi->fn_ptr[BLOCK_16X16],
1040                                              cpi->mb.mvcost,
1041                                              &distortion2,&sse);
1042             }
1043 
1044             mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
1045 
1046             /* mv cost; */
1047             rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv,
1048                                      cpi->mb.mvcost, 128);
1049         }
1050 
1051         case NEARESTMV:
1052         case NEARMV:
1053 
1054             if (mode_mv[this_mode].as_int == 0)
1055                 continue;
1056 
1057         case ZEROMV:
1058 
1059             /* Trap vectors that reach beyond the UMV borders
1060              * Note that ALL New MV, Nearest MV Near MV and Zero MV code drops
1061              * through to this point because of the lack of break statements
1062              * in the previous two cases.
1063              */
1064             if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
1065                 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
1066                 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
1067                 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
1068                 continue;
1069 
1070             rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
1071             x->e_mbd.mode_info_context->mbmi.mv.as_int =
1072                                                     mode_mv[this_mode].as_int;
1073             this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x,
1074                                           rd_adjustment);
1075 
1076             break;
1077         default:
1078             break;
1079         }
1080 
1081 #if CONFIG_TEMPORAL_DENOISING
1082         if (cpi->oxcf.noise_sensitivity)
1083         {
1084 
1085             /* Store for later use by denoiser. */
1086             if (this_mode == ZEROMV && sse < zero_mv_sse )
1087             {
1088                 zero_mv_sse = sse;
1089                 x->best_zeromv_reference_frame =
1090                         x->e_mbd.mode_info_context->mbmi.ref_frame;
1091             }
1092 
1093             /* Store the best NEWMV in x for later use in the denoiser. */
1094             if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV &&
1095                     sse < best_sse)
1096             {
1097                 best_sse = sse;
1098                 x->best_sse_inter_mode = NEWMV;
1099                 x->best_sse_mv = x->e_mbd.mode_info_context->mbmi.mv;
1100                 x->need_to_clamp_best_mvs =
1101                     x->e_mbd.mode_info_context->mbmi.need_to_clamp_mvs;
1102                 x->best_reference_frame =
1103                     x->e_mbd.mode_info_context->mbmi.ref_frame;
1104             }
1105         }
1106 #endif
1107 
1108         if (this_rd < best_rd || x->skip)
1109         {
1110             /* Note index of best mode */
1111             best_mode_index = mode_index;
1112 
1113             *returnrate = rate2;
1114             *returndistortion = distortion2;
1115             best_rd_sse = sse;
1116             best_rd = this_rd;
1117             vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
1118                        sizeof(MB_MODE_INFO));
1119 
1120             /* Testing this mode gave rise to an improvement in best error
1121              * score. Lower threshold a bit for next time
1122              */
1123             x->rd_thresh_mult[mode_index] =
1124                      (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ?
1125                      x->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT;
1126             x->rd_threshes[mode_index] =
1127                                    (cpi->rd_baseline_thresh[mode_index] >> 7) *
1128                                    x->rd_thresh_mult[mode_index];
1129         }
1130 
1131         /* If the mode did not help improve the best error case then raise the
1132          * threshold for testing that mode next time around.
1133          */
1134         else
1135         {
1136             x->rd_thresh_mult[mode_index] += 4;
1137 
1138             if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
1139                 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1140 
1141             x->rd_threshes[mode_index] =
1142                          (cpi->rd_baseline_thresh[mode_index] >> 7) *
1143                          x->rd_thresh_mult[mode_index];
1144         }
1145 
1146         if (x->skip)
1147             break;
1148     }
1149 
1150     /* Reduce the activation RD thresholds for the best choice mode */
1151     if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2)))
1152     {
1153         int best_adjustment = (x->rd_thresh_mult[best_mode_index] >> 3);
1154 
1155         x->rd_thresh_mult[best_mode_index] =
1156                         (x->rd_thresh_mult[best_mode_index]
1157                         >= (MIN_THRESHMULT + best_adjustment)) ?
1158                         x->rd_thresh_mult[best_mode_index] - best_adjustment :
1159                         MIN_THRESHMULT;
1160         x->rd_threshes[best_mode_index] =
1161                         (cpi->rd_baseline_thresh[best_mode_index] >> 7) *
1162                         x->rd_thresh_mult[best_mode_index];
1163     }
1164 
1165 
1166     {
1167         int this_rdbin = (*returndistortion >> 7);
1168 
1169         if (this_rdbin >= 1024)
1170         {
1171             this_rdbin = 1023;
1172         }
1173 
1174         x->error_bins[this_rdbin] ++;
1175     }
1176 
1177 #if CONFIG_TEMPORAL_DENOISING
1178     if (cpi->oxcf.noise_sensitivity)
1179     {
1180         int block_index = mb_row * cpi->common.mb_cols + mb_col;
1181         if (x->best_sse_inter_mode == DC_PRED)
1182         {
1183             /* No best MV found. */
1184             x->best_sse_inter_mode = best_mbmode.mode;
1185             x->best_sse_mv = best_mbmode.mv;
1186             x->need_to_clamp_best_mvs = best_mbmode.need_to_clamp_mvs;
1187             x->best_reference_frame = best_mbmode.ref_frame;
1188             best_sse = best_rd_sse;
1189         }
1190         x->increase_denoising = 0;
1191         vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse,
1192                                 recon_yoffset, recon_uvoffset,
1193                                 &cpi->common.lf_info, mb_row, mb_col,
1194                                 block_index);
1195 
1196         /* Reevaluate ZEROMV after denoising. */
1197         if (best_mbmode.ref_frame == INTRA_FRAME &&
1198             x->best_zeromv_reference_frame != INTRA_FRAME)
1199         {
1200             int this_rd = 0;
1201             int this_ref_frame = x->best_zeromv_reference_frame;
1202             rate2 = x->ref_frame_cost[this_ref_frame] +
1203                     vp8_cost_mv_ref(ZEROMV, mdcounts);
1204             distortion2 = 0;
1205 
1206             /* set up the proper prediction buffers for the frame */
1207             x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame;
1208             x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
1209             x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
1210             x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];
1211 
1212             x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
1213             x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1214             x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
1215             this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x,
1216                                           rd_adjustment);
1217 
1218             if (this_rd < best_rd)
1219             {
1220                 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
1221                            sizeof(MB_MODE_INFO));
1222             }
1223         }
1224 
1225     }
1226 #endif
1227 
1228     if (cpi->is_src_frame_alt_ref &&
1229         (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME))
1230     {
1231         x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
1232         x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME;
1233         x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
1234         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1235         x->e_mbd.mode_info_context->mbmi.mb_skip_coeff =
1236                                         (cpi->common.mb_no_coeff_skip);
1237         x->e_mbd.mode_info_context->mbmi.partitioning = 0;
1238 
1239         return;
1240     }
1241 
1242     /* set to the best mb mode, this copy can be skip if x->skip since it
1243      * already has the right content */
1244     if (!x->skip)
1245         vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode,
1246                    sizeof(MB_MODE_INFO));
1247 
1248     if (best_mbmode.mode <= B_PRED)
1249     {
1250         /* set mode_info_context->mbmi.uv_mode */
1251         pick_intra_mbuv_mode(x);
1252     }
1253 
1254     if (sign_bias
1255       != cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame])
1256         best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
1257 
1258     update_mvcount(x, &best_ref_mv);
1259 }
1260 
1261 
vp8_pick_intra_mode(MACROBLOCK * x,int * rate_)1262 void vp8_pick_intra_mode(MACROBLOCK *x, int *rate_)
1263 {
1264     int error4x4, error16x16 = INT_MAX;
1265     int rate, best_rate = 0, distortion, best_sse;
1266     MB_PREDICTION_MODE mode, best_mode = DC_PRED;
1267     int this_rd;
1268     unsigned int sse;
1269     BLOCK *b = &x->block[0];
1270     MACROBLOCKD *xd = &x->e_mbd;
1271 
1272     xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1273 
1274     pick_intra_mbuv_mode(x);
1275 
1276     for (mode = DC_PRED; mode <= TM_PRED; mode ++)
1277     {
1278         xd->mode_info_context->mbmi.mode = mode;
1279         vp8_build_intra_predictors_mby_s(xd,
1280                                          xd->dst.y_buffer - xd->dst.y_stride,
1281                                          xd->dst.y_buffer - 1,
1282                                          xd->dst.y_stride,
1283                                          xd->predictor,
1284                                          16);
1285         distortion = vp8_variance16x16
1286             (*(b->base_src), b->src_stride, xd->predictor, 16, &sse);
1287         rate = x->mbmode_cost[xd->frame_type][mode];
1288         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1289 
1290         if (error16x16 > this_rd)
1291         {
1292             error16x16 = this_rd;
1293             best_mode = mode;
1294             best_sse = sse;
1295             best_rate = rate;
1296         }
1297     }
1298     xd->mode_info_context->mbmi.mode = best_mode;
1299 
1300     error4x4 = pick_intra4x4mby_modes(x, &rate,
1301                                       &best_sse);
1302     if (error4x4 < error16x16)
1303     {
1304         xd->mode_info_context->mbmi.mode = B_PRED;
1305         best_rate = rate;
1306     }
1307 
1308     *rate_ = best_rate;
1309 }
1310