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 "vpx_config.h"
13 #include "vp8_rtcd.h"
14 #include "encodemb.h"
15 #include "encodemv.h"
16 #include "vp8/common/common.h"
17 #include "onyx_int.h"
18 #include "vp8/common/extend.h"
19 #include "vp8/common/entropymode.h"
20 #include "vp8/common/quant_common.h"
21 #include "segmentation.h"
22 #include "vp8/common/setupintrarecon.h"
23 #include "encodeintra.h"
24 #include "vp8/common/reconinter.h"
25 #include "rdopt.h"
26 #include "pickinter.h"
27 #include "vp8/common/findnearmv.h"
28 #include <stdio.h>
29 #include <limits.h>
30 #include "vp8/common/invtrans.h"
31 #include "vpx_ports/vpx_timer.h"
32 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
33 #include "bitstream.h"
34 #endif
35 #include "encodeframe.h"
36
37 extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t) ;
38 extern void vp8_calc_ref_frame_costs(int *ref_frame_cost,
39 int prob_intra,
40 int prob_last,
41 int prob_garf
42 );
43 extern void vp8_convert_rfct_to_prob(VP8_COMP *const cpi);
44 extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
45 extern void vp8_auto_select_speed(VP8_COMP *cpi);
46 extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
47 MACROBLOCK *x,
48 MB_ROW_COMP *mbr_ei,
49 int count);
50 static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x );
51
52 #ifdef MODE_STATS
53 unsigned int inter_y_modes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
54 unsigned int inter_uv_modes[4] = {0, 0, 0, 0};
55 unsigned int inter_b_modes[15] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
56 unsigned int y_modes[5] = {0, 0, 0, 0, 0};
57 unsigned int uv_modes[4] = {0, 0, 0, 0};
58 unsigned int b_modes[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
59 #endif
60
61
62 /* activity_avg must be positive, or flat regions could get a zero weight
63 * (infinite lambda), which confounds analysis.
64 * This also avoids the need for divide by zero checks in
65 * vp8_activity_masking().
66 */
67 #define VP8_ACTIVITY_AVG_MIN (64)
68
69 /* This is used as a reference when computing the source variance for the
70 * purposes of activity masking.
71 * Eventually this should be replaced by custom no-reference routines,
72 * which will be faster.
73 */
74 static const unsigned char VP8_VAR_OFFS[16]=
75 {
76 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128
77 };
78
79
80 /* Original activity measure from Tim T's code. */
tt_activity_measure(VP8_COMP * cpi,MACROBLOCK * x)81 static unsigned int tt_activity_measure( VP8_COMP *cpi, MACROBLOCK *x )
82 {
83 unsigned int act;
84 unsigned int sse;
85 /* TODO: This could also be done over smaller areas (8x8), but that would
86 * require extensive changes elsewhere, as lambda is assumed to be fixed
87 * over an entire MB in most of the code.
88 * Another option is to compute four 8x8 variances, and pick a single
89 * lambda using a non-linear combination (e.g., the smallest, or second
90 * smallest, etc.).
91 */
92 (void)cpi;
93 act = vp8_variance16x16(x->src.y_buffer,
94 x->src.y_stride, VP8_VAR_OFFS, 0, &sse);
95 act = act<<4;
96
97 /* If the region is flat, lower the activity some more. */
98 if (act < 8<<12)
99 act = act < 5<<12 ? act : 5<<12;
100
101 return act;
102 }
103
104 /* Stub for alternative experimental activity measures. */
alt_activity_measure(VP8_COMP * cpi,MACROBLOCK * x,int use_dc_pred)105 static unsigned int alt_activity_measure( VP8_COMP *cpi,
106 MACROBLOCK *x, int use_dc_pred )
107 {
108 return vp8_encode_intra(cpi,x, use_dc_pred);
109 }
110
111
112 /* Measure the activity of the current macroblock
113 * What we measure here is TBD so abstracted to this function
114 */
115 #define ALT_ACT_MEASURE 1
mb_activity_measure(VP8_COMP * cpi,MACROBLOCK * x,int mb_row,int mb_col)116 static unsigned int mb_activity_measure( VP8_COMP *cpi, MACROBLOCK *x,
117 int mb_row, int mb_col)
118 {
119 unsigned int mb_activity;
120
121 if ( ALT_ACT_MEASURE )
122 {
123 int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
124
125 /* Or use and alternative. */
126 mb_activity = alt_activity_measure( cpi, x, use_dc_pred );
127 }
128 else
129 {
130 /* Original activity measure from Tim T's code. */
131 mb_activity = tt_activity_measure( cpi, x );
132 }
133
134 if ( mb_activity < VP8_ACTIVITY_AVG_MIN )
135 mb_activity = VP8_ACTIVITY_AVG_MIN;
136
137 return mb_activity;
138 }
139
140 /* Calculate an "average" mb activity value for the frame */
141 #define ACT_MEDIAN 0
calc_av_activity(VP8_COMP * cpi,int64_t activity_sum)142 static void calc_av_activity( VP8_COMP *cpi, int64_t activity_sum )
143 {
144 #if ACT_MEDIAN
145 /* Find median: Simple n^2 algorithm for experimentation */
146 {
147 unsigned int median;
148 unsigned int i,j;
149 unsigned int * sortlist;
150 unsigned int tmp;
151
152 /* Create a list to sort to */
153 CHECK_MEM_ERROR(sortlist,
154 vpx_calloc(sizeof(unsigned int),
155 cpi->common.MBs));
156
157 /* Copy map to sort list */
158 vpx_memcpy( sortlist, cpi->mb_activity_map,
159 sizeof(unsigned int) * cpi->common.MBs );
160
161
162 /* Ripple each value down to its correct position */
163 for ( i = 1; i < cpi->common.MBs; i ++ )
164 {
165 for ( j = i; j > 0; j -- )
166 {
167 if ( sortlist[j] < sortlist[j-1] )
168 {
169 /* Swap values */
170 tmp = sortlist[j-1];
171 sortlist[j-1] = sortlist[j];
172 sortlist[j] = tmp;
173 }
174 else
175 break;
176 }
177 }
178
179 /* Even number MBs so estimate median as mean of two either side. */
180 median = ( 1 + sortlist[cpi->common.MBs >> 1] +
181 sortlist[(cpi->common.MBs >> 1) + 1] ) >> 1;
182
183 cpi->activity_avg = median;
184
185 vpx_free(sortlist);
186 }
187 #else
188 /* Simple mean for now */
189 cpi->activity_avg = (unsigned int)(activity_sum/cpi->common.MBs);
190 #endif
191
192 if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
193 cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
194
195 /* Experimental code: return fixed value normalized for several clips */
196 if ( ALT_ACT_MEASURE )
197 cpi->activity_avg = 100000;
198 }
199
200 #define USE_ACT_INDEX 0
201 #define OUTPUT_NORM_ACT_STATS 0
202
203 #if USE_ACT_INDEX
204 /* Calculate and activity index for each mb */
calc_activity_index(VP8_COMP * cpi,MACROBLOCK * x)205 static void calc_activity_index( VP8_COMP *cpi, MACROBLOCK *x )
206 {
207 VP8_COMMON *const cm = & cpi->common;
208 int mb_row, mb_col;
209
210 int64_t act;
211 int64_t a;
212 int64_t b;
213
214 #if OUTPUT_NORM_ACT_STATS
215 FILE *f = fopen("norm_act.stt", "a");
216 fprintf(f, "\n%12d\n", cpi->activity_avg );
217 #endif
218
219 /* Reset pointers to start of activity map */
220 x->mb_activity_ptr = cpi->mb_activity_map;
221
222 /* Calculate normalized mb activity number. */
223 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
224 {
225 /* for each macroblock col in image */
226 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
227 {
228 /* Read activity from the map */
229 act = *(x->mb_activity_ptr);
230
231 /* Calculate a normalized activity number */
232 a = act + 4*cpi->activity_avg;
233 b = 4*act + cpi->activity_avg;
234
235 if ( b >= a )
236 *(x->activity_ptr) = (int)((b + (a>>1))/a) - 1;
237 else
238 *(x->activity_ptr) = 1 - (int)((a + (b>>1))/b);
239
240 #if OUTPUT_NORM_ACT_STATS
241 fprintf(f, " %6d", *(x->mb_activity_ptr));
242 #endif
243 /* Increment activity map pointers */
244 x->mb_activity_ptr++;
245 }
246
247 #if OUTPUT_NORM_ACT_STATS
248 fprintf(f, "\n");
249 #endif
250
251 }
252
253 #if OUTPUT_NORM_ACT_STATS
254 fclose(f);
255 #endif
256
257 }
258 #endif
259
260 /* Loop through all MBs. Note activity of each, average activity and
261 * calculate a normalized activity for each
262 */
build_activity_map(VP8_COMP * cpi)263 static void build_activity_map( VP8_COMP *cpi )
264 {
265 MACROBLOCK *const x = & cpi->mb;
266 MACROBLOCKD *xd = &x->e_mbd;
267 VP8_COMMON *const cm = & cpi->common;
268
269 #if ALT_ACT_MEASURE
270 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
271 int recon_yoffset;
272 int recon_y_stride = new_yv12->y_stride;
273 #endif
274
275 int mb_row, mb_col;
276 unsigned int mb_activity;
277 int64_t activity_sum = 0;
278
279 /* for each macroblock row in image */
280 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
281 {
282 #if ALT_ACT_MEASURE
283 /* reset above block coeffs */
284 xd->up_available = (mb_row != 0);
285 recon_yoffset = (mb_row * recon_y_stride * 16);
286 #endif
287 /* for each macroblock col in image */
288 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
289 {
290 #if ALT_ACT_MEASURE
291 xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
292 xd->left_available = (mb_col != 0);
293 recon_yoffset += 16;
294 #endif
295 /* Copy current mb to a buffer */
296 vp8_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
297
298 /* measure activity */
299 mb_activity = mb_activity_measure( cpi, x, mb_row, mb_col );
300
301 /* Keep frame sum */
302 activity_sum += mb_activity;
303
304 /* Store MB level activity details. */
305 *x->mb_activity_ptr = mb_activity;
306
307 /* Increment activity map pointer */
308 x->mb_activity_ptr++;
309
310 /* adjust to the next column of source macroblocks */
311 x->src.y_buffer += 16;
312 }
313
314
315 /* adjust to the next row of mbs */
316 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
317
318 #if ALT_ACT_MEASURE
319 /* extend the recon for intra prediction */
320 vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
321 xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
322 #endif
323
324 }
325
326 /* Calculate an "average" MB activity */
327 calc_av_activity(cpi, activity_sum);
328
329 #if USE_ACT_INDEX
330 /* Calculate an activity index number of each mb */
331 calc_activity_index( cpi, x );
332 #endif
333
334 }
335
336 /* Macroblock activity masking */
vp8_activity_masking(VP8_COMP * cpi,MACROBLOCK * x)337 void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x)
338 {
339 #if USE_ACT_INDEX
340 x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
341 x->errorperbit = x->rdmult * 100 /(110 * x->rddiv);
342 x->errorperbit += (x->errorperbit==0);
343 #else
344 int64_t a;
345 int64_t b;
346 int64_t act = *(x->mb_activity_ptr);
347
348 /* Apply the masking to the RD multiplier. */
349 a = act + (2*cpi->activity_avg);
350 b = (2*act) + cpi->activity_avg;
351
352 x->rdmult = (unsigned int)(((int64_t)x->rdmult*b + (a>>1))/a);
353 x->errorperbit = x->rdmult * 100 /(110 * x->rddiv);
354 x->errorperbit += (x->errorperbit==0);
355 #endif
356
357 /* Activity based Zbin adjustment */
358 adjust_act_zbin(cpi, x);
359 }
360
361 static
encode_mb_row(VP8_COMP * cpi,VP8_COMMON * cm,int mb_row,MACROBLOCK * x,MACROBLOCKD * xd,TOKENEXTRA ** tp,int * segment_counts,int * totalrate)362 void encode_mb_row(VP8_COMP *cpi,
363 VP8_COMMON *cm,
364 int mb_row,
365 MACROBLOCK *x,
366 MACROBLOCKD *xd,
367 TOKENEXTRA **tp,
368 int *segment_counts,
369 int *totalrate)
370 {
371 int recon_yoffset, recon_uvoffset;
372 int mb_col;
373 int ref_fb_idx = cm->lst_fb_idx;
374 int dst_fb_idx = cm->new_fb_idx;
375 int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
376 int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
377 int map_index = (mb_row * cpi->common.mb_cols);
378
379 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
380 const int num_part = (1 << cm->multi_token_partition);
381 TOKENEXTRA * tp_start = cpi->tok;
382 vp8_writer *w;
383 #endif
384
385 #if CONFIG_MULTITHREAD
386 const int nsync = cpi->mt_sync_range;
387 const int rightmost_col = cm->mb_cols + nsync;
388 volatile const int *last_row_current_mb_col;
389 volatile int *current_mb_col = &cpi->mt_current_mb_col[mb_row];
390
391 if ((cpi->b_multi_threaded != 0) && (mb_row != 0))
392 last_row_current_mb_col = &cpi->mt_current_mb_col[mb_row - 1];
393 else
394 last_row_current_mb_col = &rightmost_col;
395 #endif
396
397 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
398 if(num_part > 1)
399 w= &cpi->bc[1 + (mb_row % num_part)];
400 else
401 w = &cpi->bc[1];
402 #endif
403
404 /* reset above block coeffs */
405 xd->above_context = cm->above_context;
406
407 xd->up_available = (mb_row != 0);
408 recon_yoffset = (mb_row * recon_y_stride * 16);
409 recon_uvoffset = (mb_row * recon_uv_stride * 8);
410
411 cpi->tplist[mb_row].start = *tp;
412 /* printf("Main mb_row = %d\n", mb_row); */
413
414 /* Distance of Mb to the top & bottom edges, specified in 1/8th pel
415 * units as they are always compared to values that are in 1/8th pel
416 */
417 xd->mb_to_top_edge = -((mb_row * 16) << 3);
418 xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
419
420 /* Set up limit values for vertical motion vector components
421 * to prevent them extending beyond the UMV borders
422 */
423 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
424 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
425 + (VP8BORDERINPIXELS - 16);
426
427 /* Set the mb activity pointer to the start of the row. */
428 x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
429
430 /* for each macroblock col in image */
431 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
432 {
433
434 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
435 *tp = cpi->tok;
436 #endif
437 /* Distance of Mb to the left & right edges, specified in
438 * 1/8th pel units as they are always compared to values
439 * that are in 1/8th pel units
440 */
441 xd->mb_to_left_edge = -((mb_col * 16) << 3);
442 xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
443
444 /* Set up limit values for horizontal motion vector components
445 * to prevent them extending beyond the UMV borders
446 */
447 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
448 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16)
449 + (VP8BORDERINPIXELS - 16);
450
451 xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
452 xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
453 xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
454 xd->left_available = (mb_col != 0);
455
456 x->rddiv = cpi->RDDIV;
457 x->rdmult = cpi->RDMULT;
458
459 /* Copy current mb to a buffer */
460 vp8_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
461
462 #if CONFIG_MULTITHREAD
463 if (cpi->b_multi_threaded != 0)
464 {
465 *current_mb_col = mb_col - 1; /* set previous MB done */
466
467 if ((mb_col & (nsync - 1)) == 0)
468 {
469 while (mb_col > (*last_row_current_mb_col - nsync))
470 {
471 x86_pause_hint();
472 thread_sleep(0);
473 }
474 }
475 }
476 #endif
477
478 if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
479 vp8_activity_masking(cpi, x);
480
481 /* Is segmentation enabled */
482 /* MB level adjustment to quantizer */
483 if (xd->segmentation_enabled)
484 {
485 /* Code to set segment id in xd->mbmi.segment_id for current MB
486 * (with range checking)
487 */
488 if (cpi->segmentation_map[map_index+mb_col] <= 3)
489 xd->mode_info_context->mbmi.segment_id = cpi->segmentation_map[map_index+mb_col];
490 else
491 xd->mode_info_context->mbmi.segment_id = 0;
492
493 vp8cx_mb_init_quantizer(cpi, x, 1);
494 }
495 else
496 /* Set to Segment 0 by default */
497 xd->mode_info_context->mbmi.segment_id = 0;
498
499 x->active_ptr = cpi->active_map + map_index + mb_col;
500
501 if (cm->frame_type == KEY_FRAME)
502 {
503 *totalrate += vp8cx_encode_intra_macroblock(cpi, x, tp);
504 #ifdef MODE_STATS
505 y_modes[xd->mbmi.mode] ++;
506 #endif
507 }
508 else
509 {
510 *totalrate += vp8cx_encode_inter_macroblock(cpi, x, tp, recon_yoffset, recon_uvoffset, mb_row, mb_col);
511
512 #ifdef MODE_STATS
513 inter_y_modes[xd->mbmi.mode] ++;
514
515 if (xd->mbmi.mode == SPLITMV)
516 {
517 int b;
518
519 for (b = 0; b < xd->mbmi.partition_count; b++)
520 {
521 inter_b_modes[x->partition->bmi[b].mode] ++;
522 }
523 }
524
525 #endif
526
527 /* Special case code for cyclic refresh
528 * If cyclic update enabled then copy xd->mbmi.segment_id; (which
529 * may have been updated based on mode during
530 * vp8cx_encode_inter_macroblock()) back into the global
531 * segmentation map
532 */
533 if ((cpi->current_layer == 0) &&
534 (cpi->cyclic_refresh_mode_enabled &&
535 xd->segmentation_enabled))
536 {
537 cpi->segmentation_map[map_index+mb_col] = xd->mode_info_context->mbmi.segment_id;
538
539 /* If the block has been refreshed mark it as clean (the
540 * magnitude of the -ve influences how long it will be before
541 * we consider another refresh):
542 * Else if it was coded (last frame 0,0) and has not already
543 * been refreshed then mark it as a candidate for cleanup
544 * next time (marked 0) else mark it as dirty (1).
545 */
546 if (xd->mode_info_context->mbmi.segment_id)
547 cpi->cyclic_refresh_map[map_index+mb_col] = -1;
548 else if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
549 {
550 if (cpi->cyclic_refresh_map[map_index+mb_col] == 1)
551 cpi->cyclic_refresh_map[map_index+mb_col] = 0;
552 }
553 else
554 cpi->cyclic_refresh_map[map_index+mb_col] = 1;
555
556 }
557 }
558
559 cpi->tplist[mb_row].stop = *tp;
560
561 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
562 /* pack tokens for this MB */
563 {
564 int tok_count = *tp - tp_start;
565 pack_tokens(w, tp_start, tok_count);
566 }
567 #endif
568 /* Increment pointer into gf usage flags structure. */
569 x->gf_active_ptr++;
570
571 /* Increment the activity mask pointers. */
572 x->mb_activity_ptr++;
573
574 /* adjust to the next column of macroblocks */
575 x->src.y_buffer += 16;
576 x->src.u_buffer += 8;
577 x->src.v_buffer += 8;
578
579 recon_yoffset += 16;
580 recon_uvoffset += 8;
581
582 /* Keep track of segment usage */
583 segment_counts[xd->mode_info_context->mbmi.segment_id] ++;
584
585 /* skip to next mb */
586 xd->mode_info_context++;
587 x->partition_info++;
588 xd->above_context++;
589 }
590
591 /* extend the recon for intra prediction */
592 vp8_extend_mb_row( &cm->yv12_fb[dst_fb_idx],
593 xd->dst.y_buffer + 16,
594 xd->dst.u_buffer + 8,
595 xd->dst.v_buffer + 8);
596
597 #if CONFIG_MULTITHREAD
598 if (cpi->b_multi_threaded != 0)
599 *current_mb_col = rightmost_col;
600 #endif
601
602 /* this is to account for the border */
603 xd->mode_info_context++;
604 x->partition_info++;
605 }
606
init_encode_frame_mb_context(VP8_COMP * cpi)607 static void init_encode_frame_mb_context(VP8_COMP *cpi)
608 {
609 MACROBLOCK *const x = & cpi->mb;
610 VP8_COMMON *const cm = & cpi->common;
611 MACROBLOCKD *const xd = & x->e_mbd;
612
613 /* GF active flags data structure */
614 x->gf_active_ptr = (signed char *)cpi->gf_active_flags;
615
616 /* Activity map pointer */
617 x->mb_activity_ptr = cpi->mb_activity_map;
618
619 x->act_zbin_adj = 0;
620
621 x->partition_info = x->pi;
622
623 xd->mode_info_context = cm->mi;
624 xd->mode_info_stride = cm->mode_info_stride;
625
626 xd->frame_type = cm->frame_type;
627
628 /* reset intra mode contexts */
629 if (cm->frame_type == KEY_FRAME)
630 vp8_init_mbmode_probs(cm);
631
632 /* Copy data over into macro block data structures. */
633 x->src = * cpi->Source;
634 xd->pre = cm->yv12_fb[cm->lst_fb_idx];
635 xd->dst = cm->yv12_fb[cm->new_fb_idx];
636
637 /* set up frame for intra coded blocks */
638 vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
639
640 vp8_build_block_offsets(x);
641
642 xd->mode_info_context->mbmi.mode = DC_PRED;
643 xd->mode_info_context->mbmi.uv_mode = DC_PRED;
644
645 xd->left_context = &cm->left_context;
646
647 x->mvc = cm->fc.mvc;
648
649 vpx_memset(cm->above_context, 0,
650 sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
651
652 /* Special case treatment when GF and ARF are not sensible options
653 * for reference
654 */
655 if (cpi->ref_frame_flags == VP8_LAST_FRAME)
656 vp8_calc_ref_frame_costs(x->ref_frame_cost,
657 cpi->prob_intra_coded,255,128);
658 else if ((cpi->oxcf.number_of_layers > 1) &&
659 (cpi->ref_frame_flags == VP8_GOLD_FRAME))
660 vp8_calc_ref_frame_costs(x->ref_frame_cost,
661 cpi->prob_intra_coded,1,255);
662 else if ((cpi->oxcf.number_of_layers > 1) &&
663 (cpi->ref_frame_flags == VP8_ALTR_FRAME))
664 vp8_calc_ref_frame_costs(x->ref_frame_cost,
665 cpi->prob_intra_coded,1,1);
666 else
667 vp8_calc_ref_frame_costs(x->ref_frame_cost,
668 cpi->prob_intra_coded,
669 cpi->prob_last_coded,
670 cpi->prob_gf_coded);
671
672 xd->fullpixel_mask = 0xffffffff;
673 if(cm->full_pixel)
674 xd->fullpixel_mask = 0xfffffff8;
675
676 vp8_zero(x->coef_counts);
677 vp8_zero(x->ymode_count);
678 vp8_zero(x->uv_mode_count)
679 x->prediction_error = 0;
680 x->intra_error = 0;
681 vp8_zero(x->count_mb_ref_frame_usage);
682 }
683
sum_coef_counts(MACROBLOCK * x,MACROBLOCK * x_thread)684 static void sum_coef_counts(MACROBLOCK *x, MACROBLOCK *x_thread)
685 {
686 int i = 0;
687 do
688 {
689 int j = 0;
690 do
691 {
692 int k = 0;
693 do
694 {
695 /* at every context */
696
697 /* calc probs and branch cts for this frame only */
698 int t = 0; /* token/prob index */
699
700 do
701 {
702 x->coef_counts [i][j][k][t] +=
703 x_thread->coef_counts [i][j][k][t];
704 }
705 while (++t < ENTROPY_NODES);
706 }
707 while (++k < PREV_COEF_CONTEXTS);
708 }
709 while (++j < COEF_BANDS);
710 }
711 while (++i < BLOCK_TYPES);
712 }
713
vp8_encode_frame(VP8_COMP * cpi)714 void vp8_encode_frame(VP8_COMP *cpi)
715 {
716 int mb_row;
717 MACROBLOCK *const x = & cpi->mb;
718 VP8_COMMON *const cm = & cpi->common;
719 MACROBLOCKD *const xd = & x->e_mbd;
720 TOKENEXTRA *tp = cpi->tok;
721 int segment_counts[MAX_MB_SEGMENTS];
722 int totalrate;
723 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
724 BOOL_CODER * bc = &cpi->bc[1]; /* bc[0] is for control partition */
725 const int num_part = (1 << cm->multi_token_partition);
726 #endif
727
728 vpx_memset(segment_counts, 0, sizeof(segment_counts));
729 totalrate = 0;
730
731 if (cpi->compressor_speed == 2)
732 {
733 if (cpi->oxcf.cpu_used < 0)
734 cpi->Speed = -(cpi->oxcf.cpu_used);
735 else
736 vp8_auto_select_speed(cpi);
737 }
738
739 /* Functions setup for all frame types so we can use MC in AltRef */
740 if(!cm->use_bilinear_mc_filter)
741 {
742 xd->subpixel_predict = vp8_sixtap_predict4x4;
743 xd->subpixel_predict8x4 = vp8_sixtap_predict8x4;
744 xd->subpixel_predict8x8 = vp8_sixtap_predict8x8;
745 xd->subpixel_predict16x16 = vp8_sixtap_predict16x16;
746 }
747 else
748 {
749 xd->subpixel_predict = vp8_bilinear_predict4x4;
750 xd->subpixel_predict8x4 = vp8_bilinear_predict8x4;
751 xd->subpixel_predict8x8 = vp8_bilinear_predict8x8;
752 xd->subpixel_predict16x16 = vp8_bilinear_predict16x16;
753 }
754
755 cpi->mb.skip_true_count = 0;
756 cpi->tok_count = 0;
757
758 #if 0
759 /* Experimental code */
760 cpi->frame_distortion = 0;
761 cpi->last_mb_distortion = 0;
762 #endif
763
764 xd->mode_info_context = cm->mi;
765
766 vp8_zero(cpi->mb.MVcount);
767
768 vp8cx_frame_init_quantizer(cpi);
769
770 vp8_initialize_rd_consts(cpi, x,
771 vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
772
773 vp8cx_initialize_me_consts(cpi, cm->base_qindex);
774
775 if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
776 {
777 /* Initialize encode frame context. */
778 init_encode_frame_mb_context(cpi);
779
780 /* Build a frame level activity map */
781 build_activity_map(cpi);
782 }
783
784 /* re-init encode frame context. */
785 init_encode_frame_mb_context(cpi);
786
787 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
788 {
789 int i;
790 for(i = 0; i < num_part; i++)
791 {
792 vp8_start_encode(&bc[i], cpi->partition_d[i + 1],
793 cpi->partition_d_end[i + 1]);
794 bc[i].error = &cm->error;
795 }
796 }
797
798 #endif
799
800 {
801 struct vpx_usec_timer emr_timer;
802 vpx_usec_timer_start(&emr_timer);
803
804 #if CONFIG_MULTITHREAD
805 if (cpi->b_multi_threaded)
806 {
807 int i;
808
809 vp8cx_init_mbrthread_data(cpi, x, cpi->mb_row_ei,
810 cpi->encoding_thread_count);
811
812 for (i = 0; i < cm->mb_rows; i++)
813 cpi->mt_current_mb_col[i] = -1;
814
815 for (i = 0; i < cpi->encoding_thread_count; i++)
816 {
817 sem_post(&cpi->h_event_start_encoding[i]);
818 }
819
820 for (mb_row = 0; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
821 {
822 vp8_zero(cm->left_context)
823
824 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
825 tp = cpi->tok;
826 #else
827 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
828 #endif
829
830 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
831
832 /* adjust to the next row of mbs */
833 x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
834 x->src.u_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
835 x->src.v_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
836
837 xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
838 x->partition_info += xd->mode_info_stride * cpi->encoding_thread_count;
839 x->gf_active_ptr += cm->mb_cols * cpi->encoding_thread_count;
840
841 if(mb_row == cm->mb_rows - 1)
842 {
843 sem_post(&cpi->h_event_end_encoding); /* signal frame encoding end */
844 }
845 }
846
847 sem_wait(&cpi->h_event_end_encoding); /* wait for other threads to finish */
848
849 for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
850 {
851 cpi->tok_count += (unsigned int)
852 (cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start);
853 }
854
855 if (xd->segmentation_enabled)
856 {
857 int j;
858
859 if (xd->segmentation_enabled)
860 {
861 for (i = 0; i < cpi->encoding_thread_count; i++)
862 {
863 for (j = 0; j < 4; j++)
864 segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
865 }
866 }
867 }
868
869 for (i = 0; i < cpi->encoding_thread_count; i++)
870 {
871 int mode_count;
872 int c_idx;
873 totalrate += cpi->mb_row_ei[i].totalrate;
874
875 cpi->mb.skip_true_count += cpi->mb_row_ei[i].mb.skip_true_count;
876
877 for(mode_count = 0; mode_count < VP8_YMODES; mode_count++)
878 cpi->mb.ymode_count[mode_count] +=
879 cpi->mb_row_ei[i].mb.ymode_count[mode_count];
880
881 for(mode_count = 0; mode_count < VP8_UV_MODES; mode_count++)
882 cpi->mb.uv_mode_count[mode_count] +=
883 cpi->mb_row_ei[i].mb.uv_mode_count[mode_count];
884
885 for(c_idx = 0; c_idx < MVvals; c_idx++)
886 {
887 cpi->mb.MVcount[0][c_idx] +=
888 cpi->mb_row_ei[i].mb.MVcount[0][c_idx];
889 cpi->mb.MVcount[1][c_idx] +=
890 cpi->mb_row_ei[i].mb.MVcount[1][c_idx];
891 }
892
893 cpi->mb.prediction_error +=
894 cpi->mb_row_ei[i].mb.prediction_error;
895 cpi->mb.intra_error += cpi->mb_row_ei[i].mb.intra_error;
896
897 for(c_idx = 0; c_idx < MAX_REF_FRAMES; c_idx++)
898 cpi->mb.count_mb_ref_frame_usage[c_idx] +=
899 cpi->mb_row_ei[i].mb.count_mb_ref_frame_usage[c_idx];
900
901 for(c_idx = 0; c_idx < MAX_ERROR_BINS; c_idx++)
902 cpi->mb.error_bins[c_idx] +=
903 cpi->mb_row_ei[i].mb.error_bins[c_idx];
904
905 /* add up counts for each thread */
906 sum_coef_counts(x, &cpi->mb_row_ei[i].mb);
907 }
908
909 }
910 else
911 #endif
912 {
913
914 /* for each macroblock row in image */
915 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
916 {
917 vp8_zero(cm->left_context)
918
919 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
920 tp = cpi->tok;
921 #endif
922
923 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
924
925 /* adjust to the next row of mbs */
926 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
927 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
928 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
929 }
930
931 cpi->tok_count = (unsigned int)(tp - cpi->tok);
932 }
933
934 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
935 {
936 int i;
937 for(i = 0; i < num_part; i++)
938 {
939 vp8_stop_encode(&bc[i]);
940 cpi->partition_sz[i+1] = bc[i].pos;
941 }
942 }
943 #endif
944
945 vpx_usec_timer_mark(&emr_timer);
946 cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
947 }
948
949
950 // Work out the segment probabilities if segmentation is enabled
951 // and needs to be updated
952 if (xd->segmentation_enabled && xd->update_mb_segmentation_map)
953 {
954 int tot_count;
955 int i;
956
957 /* Set to defaults */
958 vpx_memset(xd->mb_segment_tree_probs, 255 , sizeof(xd->mb_segment_tree_probs));
959
960 tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
961
962 if (tot_count)
963 {
964 xd->mb_segment_tree_probs[0] = ((segment_counts[0] + segment_counts[1]) * 255) / tot_count;
965
966 tot_count = segment_counts[0] + segment_counts[1];
967
968 if (tot_count > 0)
969 {
970 xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) / tot_count;
971 }
972
973 tot_count = segment_counts[2] + segment_counts[3];
974
975 if (tot_count > 0)
976 xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) / tot_count;
977
978 /* Zero probabilities not allowed */
979 for (i = 0; i < MB_FEATURE_TREE_PROBS; i ++)
980 {
981 if (xd->mb_segment_tree_probs[i] == 0)
982 xd->mb_segment_tree_probs[i] = 1;
983 }
984 }
985 }
986
987 /* projected_frame_size in units of BYTES */
988 cpi->projected_frame_size = totalrate >> 8;
989
990 /* Make a note of the percentage MBs coded Intra. */
991 if (cm->frame_type == KEY_FRAME)
992 {
993 cpi->this_frame_percent_intra = 100;
994 }
995 else
996 {
997 int tot_modes;
998
999 tot_modes = cpi->mb.count_mb_ref_frame_usage[INTRA_FRAME]
1000 + cpi->mb.count_mb_ref_frame_usage[LAST_FRAME]
1001 + cpi->mb.count_mb_ref_frame_usage[GOLDEN_FRAME]
1002 + cpi->mb.count_mb_ref_frame_usage[ALTREF_FRAME];
1003
1004 if (tot_modes)
1005 cpi->this_frame_percent_intra =
1006 cpi->mb.count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;
1007
1008 }
1009
1010 #if ! CONFIG_REALTIME_ONLY
1011 /* Adjust the projected reference frame usage probability numbers to
1012 * reflect what we have just seen. This may be useful when we make
1013 * multiple iterations of the recode loop rather than continuing to use
1014 * values from the previous frame.
1015 */
1016 if ((cm->frame_type != KEY_FRAME) && ((cpi->oxcf.number_of_layers > 1) ||
1017 (!cm->refresh_alt_ref_frame && !cm->refresh_golden_frame)))
1018 {
1019 vp8_convert_rfct_to_prob(cpi);
1020 }
1021 #endif
1022 }
vp8_setup_block_ptrs(MACROBLOCK * x)1023 void vp8_setup_block_ptrs(MACROBLOCK *x)
1024 {
1025 int r, c;
1026 int i;
1027
1028 for (r = 0; r < 4; r++)
1029 {
1030 for (c = 0; c < 4; c++)
1031 {
1032 x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
1033 }
1034 }
1035
1036 for (r = 0; r < 2; r++)
1037 {
1038 for (c = 0; c < 2; c++)
1039 {
1040 x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
1041 }
1042 }
1043
1044
1045 for (r = 0; r < 2; r++)
1046 {
1047 for (c = 0; c < 2; c++)
1048 {
1049 x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
1050 }
1051 }
1052
1053 x->block[24].src_diff = x->src_diff + 384;
1054
1055
1056 for (i = 0; i < 25; i++)
1057 {
1058 x->block[i].coeff = x->coeff + i * 16;
1059 }
1060 }
1061
vp8_build_block_offsets(MACROBLOCK * x)1062 void vp8_build_block_offsets(MACROBLOCK *x)
1063 {
1064 int block = 0;
1065 int br, bc;
1066
1067 vp8_build_block_doffsets(&x->e_mbd);
1068
1069 /* y blocks */
1070 x->thismb_ptr = &x->thismb[0];
1071 for (br = 0; br < 4; br++)
1072 {
1073 for (bc = 0; bc < 4; bc++)
1074 {
1075 BLOCK *this_block = &x->block[block];
1076 this_block->base_src = &x->thismb_ptr;
1077 this_block->src_stride = 16;
1078 this_block->src = 4 * br * 16 + 4 * bc;
1079 ++block;
1080 }
1081 }
1082
1083 /* u blocks */
1084 for (br = 0; br < 2; br++)
1085 {
1086 for (bc = 0; bc < 2; bc++)
1087 {
1088 BLOCK *this_block = &x->block[block];
1089 this_block->base_src = &x->src.u_buffer;
1090 this_block->src_stride = x->src.uv_stride;
1091 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
1092 ++block;
1093 }
1094 }
1095
1096 /* v blocks */
1097 for (br = 0; br < 2; br++)
1098 {
1099 for (bc = 0; bc < 2; bc++)
1100 {
1101 BLOCK *this_block = &x->block[block];
1102 this_block->base_src = &x->src.v_buffer;
1103 this_block->src_stride = x->src.uv_stride;
1104 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
1105 ++block;
1106 }
1107 }
1108 }
1109
sum_intra_stats(VP8_COMP * cpi,MACROBLOCK * x)1110 static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x)
1111 {
1112 const MACROBLOCKD *xd = & x->e_mbd;
1113 const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi.mode;
1114 const MB_PREDICTION_MODE uvm = xd->mode_info_context->mbmi.uv_mode;
1115
1116 #ifdef MODE_STATS
1117 const int is_key = cpi->common.frame_type == KEY_FRAME;
1118
1119 ++ (is_key ? uv_modes : inter_uv_modes)[uvm];
1120
1121 if (m == B_PRED)
1122 {
1123 unsigned int *const bct = is_key ? b_modes : inter_b_modes;
1124
1125 int b = 0;
1126
1127 do
1128 {
1129 ++ bct[xd->block[b].bmi.mode];
1130 }
1131 while (++b < 16);
1132 }
1133
1134 #endif
1135 (void)cpi;
1136 ++x->ymode_count[m];
1137 ++x->uv_mode_count[uvm];
1138
1139 }
1140
1141 /* Experimental stub function to create a per MB zbin adjustment based on
1142 * some previously calculated measure of MB activity.
1143 */
adjust_act_zbin(VP8_COMP * cpi,MACROBLOCK * x)1144 static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x )
1145 {
1146 #if USE_ACT_INDEX
1147 x->act_zbin_adj = *(x->mb_activity_ptr);
1148 #else
1149 int64_t a;
1150 int64_t b;
1151 int64_t act = *(x->mb_activity_ptr);
1152
1153 /* Apply the masking to the RD multiplier. */
1154 a = act + 4*cpi->activity_avg;
1155 b = 4*act + cpi->activity_avg;
1156
1157 if ( act > cpi->activity_avg )
1158 x->act_zbin_adj = (int)(((int64_t)b + (a>>1))/a) - 1;
1159 else
1160 x->act_zbin_adj = 1 - (int)(((int64_t)a + (b>>1))/b);
1161 #endif
1162 }
1163
vp8cx_encode_intra_macroblock(VP8_COMP * cpi,MACROBLOCK * x,TOKENEXTRA ** t)1164 int vp8cx_encode_intra_macroblock(VP8_COMP *cpi, MACROBLOCK *x,
1165 TOKENEXTRA **t)
1166 {
1167 MACROBLOCKD *xd = &x->e_mbd;
1168 int rate;
1169
1170 if (cpi->sf.RD && cpi->compressor_speed != 2)
1171 vp8_rd_pick_intra_mode(x, &rate);
1172 else
1173 vp8_pick_intra_mode(x, &rate);
1174
1175 if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
1176 {
1177 adjust_act_zbin( cpi, x );
1178 vp8_update_zbin_extra(cpi, x);
1179 }
1180
1181 if (x->e_mbd.mode_info_context->mbmi.mode == B_PRED)
1182 vp8_encode_intra4x4mby(x);
1183 else
1184 vp8_encode_intra16x16mby(x);
1185
1186 vp8_encode_intra16x16mbuv(x);
1187
1188 sum_intra_stats(cpi, x);
1189
1190 vp8_tokenize_mb(cpi, x, t);
1191
1192 if (xd->mode_info_context->mbmi.mode != B_PRED)
1193 vp8_inverse_transform_mby(xd);
1194
1195 vp8_dequant_idct_add_uv_block
1196 (xd->qcoeff+16*16, xd->dequant_uv,
1197 xd->dst.u_buffer, xd->dst.v_buffer,
1198 xd->dst.uv_stride, xd->eobs+16);
1199 return rate;
1200 }
1201 #ifdef SPEEDSTATS
1202 extern int cnt_pm;
1203 #endif
1204
1205 extern void vp8_fix_contexts(MACROBLOCKD *x);
1206
vp8cx_encode_inter_macroblock(VP8_COMP * cpi,MACROBLOCK * x,TOKENEXTRA ** t,int recon_yoffset,int recon_uvoffset,int mb_row,int mb_col)1207 int vp8cx_encode_inter_macroblock
1208 (
1209 VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
1210 int recon_yoffset, int recon_uvoffset,
1211 int mb_row, int mb_col
1212 )
1213 {
1214 MACROBLOCKD *const xd = &x->e_mbd;
1215 int intra_error = 0;
1216 int rate;
1217 int distortion;
1218
1219 x->skip = 0;
1220
1221 if (xd->segmentation_enabled)
1222 x->encode_breakout = cpi->segment_encode_breakout[xd->mode_info_context->mbmi.segment_id];
1223 else
1224 x->encode_breakout = cpi->oxcf.encode_breakout;
1225
1226 #if CONFIG_TEMPORAL_DENOISING
1227 /* Reset the best sse mode/mv for each macroblock. */
1228 x->best_reference_frame = INTRA_FRAME;
1229 x->best_zeromv_reference_frame = INTRA_FRAME;
1230 x->best_sse_inter_mode = 0;
1231 x->best_sse_mv.as_int = 0;
1232 x->need_to_clamp_best_mvs = 0;
1233 #endif
1234
1235 if (cpi->sf.RD)
1236 {
1237 int zbin_mode_boost_enabled = x->zbin_mode_boost_enabled;
1238
1239 /* Are we using the fast quantizer for the mode selection? */
1240 if(cpi->sf.use_fastquant_for_pick)
1241 {
1242 x->quantize_b = vp8_fast_quantize_b;
1243 x->quantize_b_pair = vp8_fast_quantize_b_pair;
1244
1245 /* the fast quantizer does not use zbin_extra, so
1246 * do not recalculate */
1247 x->zbin_mode_boost_enabled = 0;
1248 }
1249 vp8_rd_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate,
1250 &distortion, &intra_error);
1251
1252 /* switch back to the regular quantizer for the encode */
1253 if (cpi->sf.improved_quant)
1254 {
1255 x->quantize_b = vp8_regular_quantize_b;
1256 x->quantize_b_pair = vp8_regular_quantize_b_pair;
1257 }
1258
1259 /* restore cpi->zbin_mode_boost_enabled */
1260 x->zbin_mode_boost_enabled = zbin_mode_boost_enabled;
1261
1262 }
1263 else
1264 {
1265 vp8_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate,
1266 &distortion, &intra_error, mb_row, mb_col);
1267 }
1268
1269 x->prediction_error += distortion;
1270 x->intra_error += intra_error;
1271
1272 if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
1273 {
1274 /* Adjust the zbin based on this MB rate. */
1275 adjust_act_zbin( cpi, x );
1276 }
1277
1278 #if 0
1279 /* Experimental RD code */
1280 cpi->frame_distortion += distortion;
1281 cpi->last_mb_distortion = distortion;
1282 #endif
1283
1284 /* MB level adjutment to quantizer setup */
1285 if (xd->segmentation_enabled)
1286 {
1287 /* If cyclic update enabled */
1288 if (cpi->current_layer == 0 && cpi->cyclic_refresh_mode_enabled)
1289 {
1290 /* Clear segment_id back to 0 if not coded (last frame 0,0) */
1291 if ((xd->mode_info_context->mbmi.segment_id == 1) &&
1292 ((xd->mode_info_context->mbmi.ref_frame != LAST_FRAME) || (xd->mode_info_context->mbmi.mode != ZEROMV)))
1293 {
1294 xd->mode_info_context->mbmi.segment_id = 0;
1295
1296 /* segment_id changed, so update */
1297 vp8cx_mb_init_quantizer(cpi, x, 1);
1298 }
1299 }
1300 }
1301
1302 {
1303 /* Experimental code.
1304 * Special case for gf and arf zeromv modes, for 1 temporal layer.
1305 * Increase zbin size to supress noise.
1306 */
1307 x->zbin_mode_boost = 0;
1308 if (x->zbin_mode_boost_enabled)
1309 {
1310 if ( xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME )
1311 {
1312 if (xd->mode_info_context->mbmi.mode == ZEROMV)
1313 {
1314 if (xd->mode_info_context->mbmi.ref_frame != LAST_FRAME &&
1315 cpi->oxcf.number_of_layers == 1)
1316 x->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1317 else
1318 x->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
1319 }
1320 else if (xd->mode_info_context->mbmi.mode == SPLITMV)
1321 x->zbin_mode_boost = 0;
1322 else
1323 x->zbin_mode_boost = MV_ZBIN_BOOST;
1324 }
1325 }
1326
1327 /* The fast quantizer doesn't use zbin_extra, only do so with
1328 * the regular quantizer. */
1329 if (cpi->sf.improved_quant)
1330 vp8_update_zbin_extra(cpi, x);
1331 }
1332
1333 x->count_mb_ref_frame_usage[xd->mode_info_context->mbmi.ref_frame] ++;
1334
1335 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
1336 {
1337 vp8_encode_intra16x16mbuv(x);
1338
1339 if (xd->mode_info_context->mbmi.mode == B_PRED)
1340 {
1341 vp8_encode_intra4x4mby(x);
1342 }
1343 else
1344 {
1345 vp8_encode_intra16x16mby(x);
1346 }
1347
1348 sum_intra_stats(cpi, x);
1349 }
1350 else
1351 {
1352 int ref_fb_idx;
1353
1354 if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
1355 ref_fb_idx = cpi->common.lst_fb_idx;
1356 else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
1357 ref_fb_idx = cpi->common.gld_fb_idx;
1358 else
1359 ref_fb_idx = cpi->common.alt_fb_idx;
1360
1361 xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
1362 xd->pre.u_buffer = cpi->common.yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
1363 xd->pre.v_buffer = cpi->common.yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
1364
1365 if (!x->skip)
1366 {
1367 vp8_encode_inter16x16(x);
1368 }
1369 else
1370 vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
1371 xd->dst.u_buffer, xd->dst.v_buffer,
1372 xd->dst.y_stride, xd->dst.uv_stride);
1373
1374 }
1375
1376 if (!x->skip)
1377 {
1378 vp8_tokenize_mb(cpi, x, t);
1379
1380 if (xd->mode_info_context->mbmi.mode != B_PRED)
1381 vp8_inverse_transform_mby(xd);
1382
1383 vp8_dequant_idct_add_uv_block
1384 (xd->qcoeff+16*16, xd->dequant_uv,
1385 xd->dst.u_buffer, xd->dst.v_buffer,
1386 xd->dst.uv_stride, xd->eobs+16);
1387 }
1388 else
1389 {
1390 /* always set mb_skip_coeff as it is needed by the loopfilter */
1391 xd->mode_info_context->mbmi.mb_skip_coeff = 1;
1392
1393 if (cpi->common.mb_no_coeff_skip)
1394 {
1395 x->skip_true_count ++;
1396 vp8_fix_contexts(xd);
1397 }
1398 else
1399 {
1400 vp8_stuff_mb(cpi, x, t);
1401 }
1402 }
1403
1404 return rate;
1405 }
1406