2 * Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
12 #include "vpx_ports/config.h"
18 #include "entropymode.h"
19 #include "quant_common.h"
20 #include "segmentation_common.h"
21 #include "setupintrarecon.h"
22 #include "encodeintra.h"
23 #include "reconinter.h"
25 #include "pickinter.h"
26 #include "findnearmv.h"
27 #include "reconintra.h"
31 #include "vpx_ports/vpx_timer.h"
33 #if CONFIG_RUNTIME_CPU_DETECT
34 #define RTCD(x) &cpi->common.rtcd.x
35 #define IF_RTCD(x) (x)
38 #define IF_RTCD(x) NULL
40 extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ;
42 extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
43 extern void vp8_auto_select_speed(VP8_COMP *cpi);
44 extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
49 void vp8_build_block_offsets(MACROBLOCK *x);
50 void vp8_setup_block_ptrs(MACROBLOCK *x);
51 int vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, int recon_yoffset, int recon_uvoffset);
52 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t);
55 unsigned int inter_y_modes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
56 unsigned int inter_uv_modes[4] = {0, 0, 0, 0};
57 unsigned int inter_b_modes[15] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
58 unsigned int y_modes[5] = {0, 0, 0, 0, 0};
59 unsigned int uv_modes[4] = {0, 0, 0, 0};
60 unsigned int b_modes[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
63 // The first four entries are dummy values
64 static const int qrounding_factors[129] =
66 56, 56, 56, 56, 56, 56, 56, 56,
67 48, 48, 48, 48, 48, 48, 48, 48,
68 48, 48, 48, 48, 48, 48, 48, 48,
69 48, 48, 48, 48, 48, 48, 48, 48,
70 48, 48, 48, 48, 48, 48, 48, 48,
71 48, 48, 48, 48, 48, 48, 48, 48,
72 48, 48, 48, 48, 48, 48, 48, 48,
73 48, 48, 48, 48, 48, 48, 48, 48,
74 48, 48, 48, 48, 48, 48, 48, 48,
75 48, 48, 48, 48, 48, 48, 48, 48,
76 48, 48, 48, 48, 48, 48, 48, 48,
77 48, 48, 48, 48, 48, 48, 48, 48,
78 48, 48, 48, 48, 48, 48, 48, 48,
79 48, 48, 48, 48, 48, 48, 48, 48,
80 48, 48, 48, 48, 48, 48, 48, 48,
81 48, 48, 48, 48, 48, 48, 48, 48,
85 static const int qzbin_factors[129] =
87 64, 64, 64, 64, 80, 80, 80, 80,
88 80, 80, 80, 80, 80, 80, 80, 80,
89 80, 80, 80, 80, 80, 80, 80, 80,
90 80, 80, 80, 80, 80, 80, 80, 80,
91 80, 80, 80, 80, 80, 80, 80, 80,
92 80, 80, 80, 80, 80, 80, 80, 80,
93 80, 80, 80, 80, 80, 80, 80, 80,
94 80, 80, 80, 80, 80, 80, 80, 80,
95 80, 80, 80, 80, 80, 80, 80, 80,
96 80, 80, 80, 80, 80, 80, 80, 80,
97 80, 80, 80, 80, 80, 80, 80, 80,
98 80, 80, 80, 80, 80, 80, 80, 80,
99 80, 80, 80, 80, 80, 80, 80, 80,
100 80, 80, 80, 80, 80, 80, 80, 80,
101 80, 80, 80, 80, 80, 80, 80, 80,
102 80, 80, 80, 80, 80, 80, 80, 80,
106 static void vp8cx_invert_quant(short *quant, short *shift, short d)
111 for(l = 0; t > 1; l++)
113 t = 1 + (1<<(16+l))/d;
114 *quant = (short)(t - (1<<16));
118 void vp8cx_init_quantizer(VP8_COMP *cpi)
125 int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};
127 for (Q = 0; Q < QINDEX_RANGE; Q++)
130 quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);
131 vp8cx_invert_quant(cpi->Y1quant[Q][0] + 0,
132 cpi->Y1quant_shift[Q][0] + 0, quant_val);
133 cpi->Y1zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
134 cpi->Y1round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
135 cpi->common.Y1dequant[Q][0][0] = quant_val;
136 cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;
138 quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);
139 vp8cx_invert_quant(cpi->Y2quant[Q][0] + 0,
140 cpi->Y2quant_shift[Q][0] + 0, quant_val);
141 cpi->Y2zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
142 cpi->Y2round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
143 cpi->common.Y2dequant[Q][0][0] = quant_val;
144 cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;
146 quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);
147 vp8cx_invert_quant(cpi->UVquant[Q][0] + 0,
148 cpi->UVquant_shift[Q][0] + 0, quant_val);
149 cpi->UVzbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;
150 cpi->UVround[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
151 cpi->common.UVdequant[Q][0][0] = quant_val;
152 cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;
154 // all the ac values = ;
155 for (i = 1; i < 16; i++)
157 int rc = vp8_default_zig_zag1d[i];
161 quant_val = vp8_ac_yquant(Q);
162 vp8cx_invert_quant(cpi->Y1quant[Q][r] + c,
163 cpi->Y1quant_shift[Q][r] + c, quant_val);
164 cpi->Y1zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
165 cpi->Y1round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
166 cpi->common.Y1dequant[Q][r][c] = quant_val;
167 cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;
169 quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);
170 vp8cx_invert_quant(cpi->Y2quant[Q][r] + c,
171 cpi->Y2quant_shift[Q][r] + c, quant_val);
172 cpi->Y2zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
173 cpi->Y2round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
174 cpi->common.Y2dequant[Q][r][c] = quant_val;
175 cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;
177 quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);
178 vp8cx_invert_quant(cpi->UVquant[Q][r] + c,
179 cpi->UVquant_shift[Q][r] + c, quant_val);
180 cpi->UVzbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
181 cpi->UVround[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
182 cpi->common.UVdequant[Q][r][c] = quant_val;
183 cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;
188 void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x)
192 MACROBLOCKD *xd = &x->e_mbd;
193 MB_MODE_INFO *mbmi = &xd->mbmi;
196 // Select the baseline MB Q index.
197 if (xd->segmentation_enabled)
200 if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
201 QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
206 QIndex = cpi->common.base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
207 QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0; // Clamp to valid range
211 QIndex = cpi->common.base_qindex;
214 zbin_extra = (cpi->common.Y1dequant[QIndex][0][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
216 for (i = 0; i < 16; i++)
218 x->block[i].quant = cpi->Y1quant[QIndex];
219 x->block[i].quant_shift = cpi->Y1quant_shift[QIndex];
220 x->block[i].zbin = cpi->Y1zbin[QIndex];
221 x->block[i].round = cpi->Y1round[QIndex];
222 x->e_mbd.block[i].dequant = cpi->common.Y1dequant[QIndex];
223 x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex];
224 x->block[i].zbin_extra = (short)zbin_extra;
228 zbin_extra = (cpi->common.UVdequant[QIndex][0][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
230 for (i = 16; i < 24; i++)
232 x->block[i].quant = cpi->UVquant[QIndex];
233 x->block[i].quant_shift = cpi->UVquant_shift[QIndex];
234 x->block[i].zbin = cpi->UVzbin[QIndex];
235 x->block[i].round = cpi->UVround[QIndex];
236 x->e_mbd.block[i].dequant = cpi->common.UVdequant[QIndex];
237 x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex];
238 x->block[i].zbin_extra = (short)zbin_extra;
242 zbin_extra = (cpi->common.Y2dequant[QIndex][0][1] * ((cpi->zbin_over_quant / 2) + cpi->zbin_mode_boost)) >> 7;
243 x->block[24].quant = cpi->Y2quant[QIndex];
244 x->block[24].quant_shift = cpi->Y2quant_shift[QIndex];
245 x->block[24].zbin = cpi->Y2zbin[QIndex];
246 x->block[24].round = cpi->Y2round[QIndex];
247 x->e_mbd.block[24].dequant = cpi->common.Y2dequant[QIndex];
248 x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex];
249 x->block[24].zbin_extra = (short)zbin_extra;
252 void vp8cx_frame_init_quantizer(VP8_COMP *cpi)
254 // vp8cx_init_quantizer() is first called in vp8_create_compressor(). A check is added here so that vp8cx_init_quantizer() is only called
255 // when these values are not all zero.
256 if (cpi->common.y1dc_delta_q | cpi->common.y2dc_delta_q | cpi->common.uvdc_delta_q | cpi->common.y2ac_delta_q | cpi->common.uvac_delta_q)
258 vp8cx_init_quantizer(cpi);
261 // MB level quantizer setup
262 vp8cx_mb_init_quantizer(cpi, &cpi->mb);
268 void encode_mb_row(VP8_COMP *cpi,
278 int recon_yoffset, recon_uvoffset;
280 int recon_y_stride = cm->last_frame.y_stride;
281 int recon_uv_stride = cm->last_frame.uv_stride;
282 int seg_map_index = (mb_row * cpi->common.mb_cols);
285 // reset above block coeffs
286 xd->above_context[Y1CONTEXT] = cm->above_context[Y1CONTEXT];
287 xd->above_context[UCONTEXT ] = cm->above_context[UCONTEXT ];
288 xd->above_context[VCONTEXT ] = cm->above_context[VCONTEXT ];
289 xd->above_context[Y2CONTEXT] = cm->above_context[Y2CONTEXT];
291 xd->up_available = (mb_row != 0);
292 recon_yoffset = (mb_row * recon_y_stride * 16);
293 recon_uvoffset = (mb_row * recon_uv_stride * 8);
295 cpi->tplist[mb_row].start = *tp;
296 //printf("Main mb_row = %d\n", mb_row);
298 // for each macroblock col in image
299 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
301 // Distance of Mb to the various image edges.
302 // These specified to 8th pel as they are always compared to values that are in 1/8th pel units
303 xd->mb_to_left_edge = -((mb_col * 16) << 3);
304 xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
305 xd->mb_to_top_edge = -((mb_row * 16) << 3);
306 xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
308 // Set up limit values for motion vectors used to prevent them extending outside the UMV borders
309 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
310 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
311 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
312 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
314 xd->dst.y_buffer = cm->new_frame.y_buffer + recon_yoffset;
315 xd->dst.u_buffer = cm->new_frame.u_buffer + recon_uvoffset;
316 xd->dst.v_buffer = cm->new_frame.v_buffer + recon_uvoffset;
317 xd->left_available = (mb_col != 0);
319 // Is segmentation enabled
320 // MB level adjutment to quantizer
321 if (xd->segmentation_enabled)
323 // Code to set segment id in xd->mbmi.segment_id for current MB (with range checking)
324 if (cpi->segmentation_map[seg_map_index+mb_col] <= 3)
325 xd->mbmi.segment_id = cpi->segmentation_map[seg_map_index+mb_col];
327 xd->mbmi.segment_id = 0;
329 vp8cx_mb_init_quantizer(cpi, x);
332 xd->mbmi.segment_id = 0; // Set to Segment 0 by default
334 x->active_ptr = cpi->active_map + seg_map_index + mb_col;
336 if (cm->frame_type == KEY_FRAME)
338 *totalrate += vp8cx_encode_intra_macro_block(cpi, x, tp);
340 y_modes[xd->mbmi.mode] ++;
345 *totalrate += vp8cx_encode_inter_macroblock(cpi, x, tp, recon_yoffset, recon_uvoffset);
348 inter_y_modes[xd->mbmi.mode] ++;
350 if (xd->mbmi.mode == SPLITMV)
354 for (b = 0; b < xd->mbmi.partition_count; b++)
356 inter_b_modes[xd->mbmi.partition_bmi[b].mode] ++;
362 // Count of last ref frame 0,0 useage
363 if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame == LAST_FRAME))
364 cpi->inter_zz_count ++;
366 // Special case code for cyclic refresh
367 // If cyclic update enabled then copy xd->mbmi.segment_id; (which may have been updated based on mode
368 // during vp8cx_encode_inter_macroblock()) back into the global sgmentation map
369 if (cpi->cyclic_refresh_mode_enabled && xd->segmentation_enabled)
371 cpi->segmentation_map[seg_map_index+mb_col] = xd->mbmi.segment_id;
373 // If the block has been refreshed mark it as clean (the magnitude of the -ve influences how long it will be before we consider another refresh):
374 // Else if it was coded (last frame 0,0) and has not already been refreshed then mark it as a candidate for cleanup next time (marked 0)
375 // else mark it as dirty (1).
376 if (xd->mbmi.segment_id)
377 cpi->cyclic_refresh_map[seg_map_index+mb_col] = -1;
378 else if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame == LAST_FRAME))
380 if (cpi->cyclic_refresh_map[seg_map_index+mb_col] == 1)
381 cpi->cyclic_refresh_map[seg_map_index+mb_col] = 0;
384 cpi->cyclic_refresh_map[seg_map_index+mb_col] = 1;
389 cpi->tplist[mb_row].stop = *tp;
391 xd->gf_active_ptr++; // Increment pointer into gf useage flags structure for next mb
393 // store macroblock mode info into context array
394 vpx_memcpy(&xd->mode_info_context->mbmi, &xd->mbmi, sizeof(xd->mbmi));
396 for (i = 0; i < 16; i++)
397 vpx_memcpy(&xd->mode_info_context->bmi[i], &xd->block[i].bmi, sizeof(xd->block[i].bmi));
399 // adjust to the next column of macroblocks
400 x->src.y_buffer += 16;
401 x->src.u_buffer += 8;
402 x->src.v_buffer += 8;
407 // Keep track of segment useage
408 segment_counts[xd->mbmi.segment_id] ++;
411 xd->mode_info_context++;
413 xd->above_context[Y1CONTEXT] += 4;
414 xd->above_context[UCONTEXT ] += 2;
415 xd->above_context[VCONTEXT ] += 2;
416 xd->above_context[Y2CONTEXT] ++;
417 cpi->current_mb_col_main = mb_col;
420 //extend the recon for intra prediction
423 xd->dst.y_buffer + 16,
424 xd->dst.u_buffer + 8,
425 xd->dst.v_buffer + 8);
427 // this is to account for the border
428 xd->mode_info_context++;
435 void vp8_encode_frame(VP8_COMP *cpi)
438 MACROBLOCK *const x = & cpi->mb;
439 VP8_COMMON *const cm = & cpi->common;
440 MACROBLOCKD *const xd = & x->e_mbd;
443 TOKENEXTRA *tp = cpi->tok;
444 int segment_counts[MAX_MB_SEGMENTS];
447 if (cm->frame_type != KEY_FRAME)
449 if (cm->mcomp_filter_type == SIXTAP)
451 xd->subpixel_predict = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap4x4);
452 xd->subpixel_predict8x4 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap8x4);
453 xd->subpixel_predict8x8 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap8x8);
454 xd->subpixel_predict16x16 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap16x16);
458 xd->subpixel_predict = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear4x4);
459 xd->subpixel_predict8x4 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear8x4);
460 xd->subpixel_predict8x8 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear8x8);
461 xd->subpixel_predict16x16 = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear16x16);
467 // For key frames make sure the intra ref frame probability value
468 // is set to "all intra"
469 //cpi->prob_intra_coded = 255;
473 xd->gf_active_ptr = (signed char *)cm->gf_active_flags; // Point to base of GF active flags data structure
475 x->vector_range = 32;
477 // Count of MBs using the alternate Q if any
480 // Reset frame count of inter 0,0 motion vector useage.
481 cpi->inter_zz_count = 0;
483 vpx_memset(segment_counts, 0, sizeof(segment_counts));
485 cpi->prediction_error = 0;
486 cpi->intra_error = 0;
487 cpi->skip_true_count = 0;
488 cpi->skip_false_count = 0;
492 cpi->frame_distortion = 0;
493 cpi->last_mb_distortion = 0;
498 xd->mode_info = cm->mi - 1;
500 xd->mode_info_context = cm->mi;
501 xd->mode_info_stride = cm->mode_info_stride;
503 xd->frame_type = cm->frame_type;
505 xd->frames_since_golden = cm->frames_since_golden;
506 xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
507 vp8_zero(cpi->MVcount);
508 // vp8_zero( Contexts)
509 vp8_zero(cpi->coef_counts);
511 // reset intra mode contexts
512 if (cm->frame_type == KEY_FRAME)
513 vp8_init_mbmode_probs(cm);
516 vp8cx_frame_init_quantizer(cpi);
518 if (cpi->compressor_speed == 2)
520 if (cpi->oxcf.cpu_used < 0)
521 cpi->Speed = -(cpi->oxcf.cpu_used);
523 vp8_auto_select_speed(cpi);
526 vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
527 //vp8_initialize_rd_consts( cpi, vp8_dc_quant(cpi->avg_frame_qindex, cm->y1dc_delta_q) );
528 vp8cx_initialize_me_consts(cpi, cm->base_qindex);
529 //vp8cx_initialize_me_consts( cpi, cpi->avg_frame_qindex);
531 // Copy data over into macro block data sturctures.
533 x->src = * cpi->Source;
534 xd->pre = cm->last_frame;
535 xd->dst = cm->new_frame;
537 // set up frame new frame for intra coded blocks
539 vp8_setup_intra_recon(&cm->new_frame);
541 vp8_build_block_offsets(x);
543 vp8_setup_block_dptrs(&x->e_mbd);
545 vp8_setup_block_ptrs(x);
547 x->rddiv = cpi->RDDIV;
548 x->rdmult = cpi->RDMULT;
551 // Experimental rd code
552 // 2 Pass - Possibly set Rdmult based on last frame distortion + this frame target bits or other metrics
553 // such as cpi->rate_correction_factor that indicate relative complexity.
554 /*if ( cpi->pass == 2 && (cpi->last_frame_distortion > 0) && (cpi->target_bits_per_mb > 0) )
556 //x->rdmult = ((cpi->last_frame_distortion * 256)/cpi->common.MBs)/ cpi->target_bits_per_mb;
557 x->rdmult = (int)(cpi->RDMULT * cpi->rate_correction_factor);
560 x->rdmult = cpi->RDMULT; */
561 //x->rdmult = (int)(cpi->RDMULT * pow( (cpi->rate_correction_factor * 2.0), 0.75 ));
564 xd->mbmi.mode = DC_PRED;
565 xd->mbmi.uv_mode = DC_PRED;
567 xd->left_context = cm->left_context;
569 vp8_zero(cpi->count_mb_ref_frame_usage)
570 vp8_zero(cpi->ymode_count)
571 vp8_zero(cpi->uv_mode_count)
575 // vp8_zero( entropy_stats)
577 ENTROPY_CONTEXT **p = cm->above_context;
578 const size_t L = cm->mb_cols;
580 vp8_zero_array(p [Y1CONTEXT], L * 4)
581 vp8_zero_array(p [ UCONTEXT], L * 2)
582 vp8_zero_array(p [ VCONTEXT], L * 2)
583 vp8_zero_array(p [Y2CONTEXT], L)
588 struct vpx_usec_timer emr_timer;
589 vpx_usec_timer_start(&emr_timer);
591 if (!cpi->b_multi_threaded)
593 // for each macroblock row in image
594 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
597 vp8_zero(cm->left_context)
599 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
601 // adjust to the next row of mbs
602 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
603 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
604 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
607 cpi->tok_count = tp - cpi->tok;
612 #if CONFIG_MULTITHREAD
613 vp8cx_init_mbrthread_data(cpi, x, cpi->mb_row_ei, 1, cpi->encoding_thread_count);
615 for (mb_row = 0; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
618 cpi->current_mb_col_main = -1;
620 for (i = 0; i < cpi->encoding_thread_count; i++)
622 if ((mb_row + i + 1) >= cm->mb_rows)
625 cpi->mb_row_ei[i].mb_row = mb_row + i + 1;
626 cpi->mb_row_ei[i].tp = cpi->tok + (mb_row + i + 1) * (cm->mb_cols * 16 * 24);
627 cpi->mb_row_ei[i].current_mb_col = -1;
628 //SetEvent(cpi->h_event_mbrencoding[i]);
629 sem_post(&cpi->h_event_mbrencoding[i]);
632 vp8_zero(cm->left_context)
634 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
636 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
638 // adjust to the next row of mbs
639 x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
640 x->src.u_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
641 x->src.v_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
643 xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
645 if (mb_row < cm->mb_rows - 1)
646 //WaitForSingleObject(cpi->h_event_main, INFINITE);
647 sem_wait(&cpi->h_event_main);
651 for( ;mb_row<cm->mb_rows; mb_row ++)
653 vp8_zero( cm->left_context)
655 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
657 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
658 // adjust to the next row of mbs
659 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
660 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
661 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
667 for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
669 cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
672 if (xd->segmentation_enabled)
677 if (xd->segmentation_enabled)
680 for (i = 0; i < cpi->encoding_thread_count; i++)
682 for (j = 0; j < 4; j++)
683 segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
689 for (i = 0; i < cpi->encoding_thread_count; i++)
691 totalrate += cpi->mb_row_ei[i].totalrate;
698 vpx_usec_timer_mark(&emr_timer);
699 cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
704 // Work out the segment probabilites if segmentation is enabled
705 if (xd->segmentation_enabled)
711 vpx_memset(xd->mb_segment_tree_probs, 255 , sizeof(xd->mb_segment_tree_probs));
713 tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
717 xd->mb_segment_tree_probs[0] = ((segment_counts[0] + segment_counts[1]) * 255) / tot_count;
719 tot_count = segment_counts[0] + segment_counts[1];
723 xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) / tot_count;
726 tot_count = segment_counts[2] + segment_counts[3];
729 xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) / tot_count;
731 // Zero probabilities not allowed
732 for (i = 0; i < MB_FEATURE_TREE_PROBS; i ++)
734 if (xd->mb_segment_tree_probs[i] == 0)
735 xd->mb_segment_tree_probs[i] = 1;
740 // 256 rate units to the bit
741 cpi->projected_frame_size = totalrate >> 8; // projected_frame_size in units of BYTES
743 // Make a note of the percentage MBs coded Intra.
744 if (cm->frame_type == KEY_FRAME)
746 cpi->this_frame_percent_intra = 100;
752 tot_modes = cpi->count_mb_ref_frame_usage[INTRA_FRAME]
753 + cpi->count_mb_ref_frame_usage[LAST_FRAME]
754 + cpi->count_mb_ref_frame_usage[GOLDEN_FRAME]
755 + cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
758 cpi->this_frame_percent_intra = cpi->count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;
765 int flag[2] = {0, 0};
767 for (cnt = 0; cnt < MVPcount; cnt++)
769 if (cm->fc.pre_mvc[0][cnt] != cm->fc.mvc[0][cnt])
772 vpx_memcpy(cm->fc.pre_mvc[0], cm->fc.mvc[0], MVPcount);
777 for (cnt = 0; cnt < MVPcount; cnt++)
779 if (cm->fc.pre_mvc[1][cnt] != cm->fc.mvc[1][cnt])
782 vpx_memcpy(cm->fc.pre_mvc[1], cm->fc.mvc[1], MVPcount);
787 if (flag[0] || flag[1])
788 vp8_build_component_cost_table(cpi->mb.mvcost, cpi->mb.mvsadcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
792 // Adjust the projected reference frame useage probability numbers to reflect
793 // what we have just seen. This may be usefull when we make multiple itterations
794 // of the recode loop rather than continuing to use values from the previous frame.
795 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_alt_ref_frame && !cm->refresh_golden_frame)
797 const int *const rfct = cpi->count_mb_ref_frame_usage;
798 const int rf_intra = rfct[INTRA_FRAME];
799 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
801 if ((rf_intra + rf_inter) > 0)
803 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
805 if (cpi->prob_intra_coded < 1)
806 cpi->prob_intra_coded = 1;
808 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
810 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
812 if (cpi->prob_last_coded < 1)
813 cpi->prob_last_coded = 1;
815 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
816 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
818 if (cpi->prob_gf_coded < 1)
819 cpi->prob_gf_coded = 1;
825 // Keep record of the total distortion this time around for future use
826 cpi->last_frame_distortion = cpi->frame_distortion;
830 void vp8_setup_block_ptrs(MACROBLOCK *x)
835 for (r = 0; r < 4; r++)
837 for (c = 0; c < 4; c++)
839 x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
843 for (r = 0; r < 2; r++)
845 for (c = 0; c < 2; c++)
847 x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
852 for (r = 0; r < 2; r++)
854 for (c = 0; c < 2; c++)
856 x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
860 x->block[24].src_diff = x->src_diff + 384;
863 for (i = 0; i < 25; i++)
865 x->block[i].coeff = x->coeff + i * 16;
869 void vp8_build_block_offsets(MACROBLOCK *x)
874 vp8_build_block_doffsets(&x->e_mbd);
877 for (br = 0; br < 4; br++)
879 for (bc = 0; bc < 4; bc++)
881 BLOCK *this_block = &x->block[block];
882 this_block->base_src = &x->src.y_buffer;
883 this_block->src_stride = x->src.y_stride;
884 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
890 for (br = 0; br < 2; br++)
892 for (bc = 0; bc < 2; bc++)
894 BLOCK *this_block = &x->block[block];
895 this_block->base_src = &x->src.u_buffer;
896 this_block->src_stride = x->src.uv_stride;
897 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
903 for (br = 0; br < 2; br++)
905 for (bc = 0; bc < 2; bc++)
907 BLOCK *this_block = &x->block[block];
908 this_block->base_src = &x->src.v_buffer;
909 this_block->src_stride = x->src.uv_stride;
910 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
916 static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x)
918 const MACROBLOCKD *xd = & x->e_mbd;
919 const MB_PREDICTION_MODE m = xd->mbmi.mode;
920 const MB_PREDICTION_MODE uvm = xd->mbmi.uv_mode;
923 const int is_key = cpi->common.frame_type == KEY_FRAME;
925 ++ (is_key ? uv_modes : inter_uv_modes)[uvm];
929 unsigned int *const bct = is_key ? b_modes : inter_b_modes;
935 ++ bct[xd->block[b].bmi.mode];
942 ++cpi->ymode_count[m];
943 ++cpi->uv_mode_count[uvm];
946 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t)
948 int Error4x4, Error16x16, error_uv;
949 B_PREDICTION_MODE intra_bmodes[16];
950 int rate4x4, rate16x16, rateuv;
951 int dist4x4, dist16x16, distuv;
953 int rate4x4_tokenonly = 0;
954 int rate16x16_tokenonly = 0;
955 int rateuv_tokenonly = 0;
958 x->e_mbd.mbmi.ref_frame = INTRA_FRAME;
960 #if !(CONFIG_REALTIME_ONLY)
962 if (cpi->sf.RD || cpi->compressor_speed != 2)
964 Error4x4 = vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate4x4, &rate4x4_tokenonly, &dist4x4);
966 //save the b modes for possible later use
967 for (i = 0; i < 16; i++)
968 intra_bmodes[i] = x->e_mbd.block[i].bmi.mode;
970 Error16x16 = vp8_rd_pick_intra16x16mby_mode(cpi, x, &rate16x16, &rate16x16_tokenonly, &dist16x16);
972 error_uv = vp8_rd_pick_intra_mbuv_mode(cpi, x, &rateuv, &rateuv_tokenonly, &distuv);
974 x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
976 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
979 if (Error4x4 < Error16x16)
982 x->e_mbd.mbmi.mode = B_PRED;
984 // get back the intra block modes
985 for (i = 0; i < 16; i++)
986 x->e_mbd.block[i].bmi.mode = intra_bmodes[i];
988 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
989 cpi->prediction_error += Error4x4 ;
991 // Experimental RD code
992 cpi->frame_distortion += dist4x4;
997 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1001 // Experimental RD code
1002 cpi->prediction_error += Error16x16;
1003 cpi->frame_distortion += dist16x16;
1007 sum_intra_stats(cpi, x);
1009 vp8_tokenize_mb(cpi, &x->e_mbd, t);
1015 int rate2, distortion2;
1016 MB_PREDICTION_MODE mode, best_mode = DC_PRED;
1018 Error16x16 = INT_MAX;
1020 for (mode = DC_PRED; mode <= TM_PRED; mode ++)
1022 x->e_mbd.mbmi.mode = mode;
1023 vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
1024 distortion2 = VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16prederror)(x->src.y_buffer, x->src.y_stride, x->e_mbd.predictor, 16, 0x7fffffff);
1025 rate2 = x->mbmode_cost[x->e_mbd.frame_type][mode];
1026 this_rd = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1028 if (Error16x16 > this_rd)
1030 Error16x16 = this_rd;
1035 vp8_pick_intra4x4mby_modes(IF_RTCD(&cpi->rtcd), x, &rate2, &distortion2);
1037 if (distortion2 == INT_MAX)
1040 Error4x4 = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1042 x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
1044 if (Error4x4 < Error16x16)
1046 x->e_mbd.mbmi.mode = B_PRED;
1047 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1048 cpi->prediction_error += Error4x4;
1052 x->e_mbd.mbmi.mode = best_mode;
1053 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1054 cpi->prediction_error += Error16x16;
1057 vp8_pick_intra_mbuv_mode(x);
1058 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1059 sum_intra_stats(cpi, x);
1060 vp8_tokenize_mb(cpi, &x->e_mbd, t);
1069 extern void vp8_fix_contexts(VP8_COMP *cpi, MACROBLOCKD *x);
1071 int vp8cx_encode_inter_macroblock
1073 VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
1074 int recon_yoffset, int recon_uvoffset
1077 MACROBLOCKD *const xd = &x->e_mbd;
1079 int intra_error = 0;
1085 if (xd->segmentation_enabled)
1086 x->encode_breakout = cpi->segment_encode_breakout[xd->mbmi.segment_id];
1088 x->encode_breakout = cpi->oxcf.encode_breakout;
1090 #if !(CONFIG_REALTIME_ONLY)
1094 inter_error = vp8_rd_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1098 inter_error = vp8_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1101 cpi->prediction_error += inter_error;
1102 cpi->intra_error += intra_error;
1105 // Experimental RD code
1106 cpi->frame_distortion += distortion;
1107 cpi->last_mb_distortion = distortion;
1110 // MB level adjutment to quantizer setup
1111 if (xd->segmentation_enabled || cpi->zbin_mode_boost_enabled)
1113 // If cyclic update enabled
1114 if (cpi->cyclic_refresh_mode_enabled)
1116 // Clear segment_id back to 0 if not coded (last frame 0,0)
1117 if ((xd->mbmi.segment_id == 1) &&
1118 ((xd->mbmi.ref_frame != LAST_FRAME) || (xd->mbmi.mode != ZEROMV)))
1120 xd->mbmi.segment_id = 0;
1124 // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1125 if (cpi->zbin_mode_boost_enabled)
1127 if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame != LAST_FRAME))
1128 cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1130 cpi->zbin_mode_boost = 0;
1133 vp8cx_mb_init_quantizer(cpi, x);
1136 cpi->count_mb_ref_frame_usage[xd->mbmi.ref_frame] ++;
1138 if (xd->mbmi.ref_frame == INTRA_FRAME)
1140 x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
1142 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1144 if (xd->mbmi.mode == B_PRED)
1146 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1150 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1153 sum_intra_stats(cpi, x);
1161 vp8_find_near_mvs(xd, xd->mode_info_context,
1162 &nearest, &nearby, &best_ref_mv, mdcounts, xd->mbmi.ref_frame, cpi->common.ref_frame_sign_bias);
1164 vp8_build_uvmvs(xd, cpi->common.full_pixel);
1166 // store motion vectors in our motion vector list
1167 if (xd->mbmi.ref_frame == LAST_FRAME)
1169 // Set up pointers for this macro block into the previous frame recon buffer
1170 xd->pre.y_buffer = cpi->common.last_frame.y_buffer + recon_yoffset;
1171 xd->pre.u_buffer = cpi->common.last_frame.u_buffer + recon_uvoffset;
1172 xd->pre.v_buffer = cpi->common.last_frame.v_buffer + recon_uvoffset;
1174 else if (xd->mbmi.ref_frame == GOLDEN_FRAME)
1176 // Set up pointers for this macro block into the golden frame recon buffer
1177 xd->pre.y_buffer = cpi->common.golden_frame.y_buffer + recon_yoffset;
1178 xd->pre.u_buffer = cpi->common.golden_frame.u_buffer + recon_uvoffset;
1179 xd->pre.v_buffer = cpi->common.golden_frame.v_buffer + recon_uvoffset;
1183 // Set up pointers for this macro block into the alternate reference frame recon buffer
1184 xd->pre.y_buffer = cpi->common.alt_ref_frame.y_buffer + recon_yoffset;
1185 xd->pre.u_buffer = cpi->common.alt_ref_frame.u_buffer + recon_uvoffset;
1186 xd->pre.v_buffer = cpi->common.alt_ref_frame.v_buffer + recon_uvoffset;
1189 if (xd->mbmi.mode == SPLITMV)
1193 for (i = 0; i < 16; i++)
1195 if (xd->block[i].bmi.mode == NEW4X4)
1197 cpi->MVcount[0][mv_max+((xd->block[i].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1198 cpi->MVcount[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1202 else if (xd->mbmi.mode == NEWMV)
1204 cpi->MVcount[0][mv_max+((xd->block[0].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1205 cpi->MVcount[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1208 if (!x->skip && !x->e_mbd.mbmi.force_no_skip)
1210 vp8_encode_inter16x16(IF_RTCD(&cpi->rtcd), x);
1212 // Clear mb_skip_coeff if mb_no_coeff_skip is not set
1213 if (!cpi->common.mb_no_coeff_skip)
1214 xd->mbmi.mb_skip_coeff = 0;
1218 vp8_stuff_inter16x16(x);
1222 vp8_tokenize_mb(cpi, xd, t);
1225 if (cpi->common.mb_no_coeff_skip)
1227 if (xd->mbmi.mode != B_PRED && xd->mbmi.mode != SPLITMV)
1228 xd->mbmi.dc_diff = 0;
1230 xd->mbmi.dc_diff = 1;
1232 xd->mbmi.mb_skip_coeff = 1;
1233 cpi->skip_true_count ++;
1234 vp8_fix_contexts(cpi, xd);
1238 vp8_stuff_mb(cpi, xd, t);
1239 xd->mbmi.mb_skip_coeff = 0;
1240 cpi->skip_false_count ++;