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_ports/config.h"
13 #include "encodemb.h"
14 #include "encodemv.h"
15 #include "common.h"
16 #include "onyx_int.h"
17 #include "extend.h"
18 #include "entropymode.h"
19 #include "quant_common.h"
20 #include "segmentation.h"
21 #include "setupintrarecon.h"
22 #include "encodeintra.h"
23 #include "reconinter.h"
24 #include "rdopt.h"
25 #include "pickinter.h"
26 #include "findnearmv.h"
27 #include "reconintra.h"
28 #include <stdio.h>
29 #include <limits.h>
30 #include "subpixel.h"
31 #include "vpx_ports/vpx_timer.h"
32
33 #if CONFIG_RUNTIME_CPU_DETECT
34 #define RTCD(x) &cpi->common.rtcd.x
35 #define IF_RTCD(x) (x)
36 #else
37 #define RTCD(x) NULL
38 #define IF_RTCD(x) NULL
39 #endif
40 extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ;
41
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,
45 MACROBLOCK *x,
46 MB_ROW_COMP *mbr_ei,
47 int mb_row,
48 int count);
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);
53
54 #ifdef MODE_STATS
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};
61 #endif
62
63 static const int qrounding_factors[129] =
64 {
65 56, 56, 56, 56, 48, 48, 56, 56,
66 48, 48, 48, 48, 48, 48, 48, 48,
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,
82 };
83
84 static const int qzbin_factors[129] =
85 {
86 72, 72, 72, 72, 80, 80, 72, 72,
87 80, 80, 80, 80, 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,
103 };
104
105 static const int qrounding_factors_y2[129] =
106 {
107 56, 56, 56, 56, 48, 48, 56, 56,
108 48, 48, 48, 48, 48, 48, 48, 48,
109 48, 48, 48, 48, 48, 48, 48, 48,
110 48, 48, 48, 48, 48, 48, 48, 48,
111 48, 48, 48, 48, 48, 48, 48, 48,
112 48, 48, 48, 48, 48, 48, 48, 48,
113 48, 48, 48, 48, 48, 48, 48, 48,
114 48, 48, 48, 48, 48, 48, 48, 48,
115 48, 48, 48, 48, 48, 48, 48, 48,
116 48, 48, 48, 48, 48, 48, 48, 48,
117 48, 48, 48, 48, 48, 48, 48, 48,
118 48, 48, 48, 48, 48, 48, 48, 48,
119 48, 48, 48, 48, 48, 48, 48, 48,
120 48, 48, 48, 48, 48, 48, 48, 48,
121 48, 48, 48, 48, 48, 48, 48, 48,
122 48, 48, 48, 48, 48, 48, 48, 48,
123 48,
124 };
125
126 static const int qzbin_factors_y2[129] =
127 {
128 72, 72, 72, 72, 80, 80, 72, 72,
129 80, 80, 80, 80, 80, 80, 80, 80,
130 80, 80, 80, 80, 80, 80, 80, 80,
131 80, 80, 80, 80, 80, 80, 80, 80,
132 80, 80, 80, 80, 80, 80, 80, 80,
133 80, 80, 80, 80, 80, 80, 80, 80,
134 80, 80, 80, 80, 80, 80, 80, 80,
135 80, 80, 80, 80, 80, 80, 80, 80,
136 80, 80, 80, 80, 80, 80, 80, 80,
137 80, 80, 80, 80, 80, 80, 80, 80,
138 80, 80, 80, 80, 80, 80, 80, 80,
139 80, 80, 80, 80, 80, 80, 80, 80,
140 80, 80, 80, 80, 80, 80, 80, 80,
141 80, 80, 80, 80, 80, 80, 80, 80,
142 80, 80, 80, 80, 80, 80, 80, 80,
143 80, 80, 80, 80, 80, 80, 80, 80,
144 80,
145 };
146
147 //#define EXACT_QUANT
148 #ifdef EXACT_QUANT
vp8cx_invert_quant(short * quant,short * shift,short d)149 static void vp8cx_invert_quant(short *quant, short *shift, short d)
150 {
151 unsigned t;
152 int l;
153 t = d;
154 for(l = 0; t > 1; l++)
155 t>>=1;
156 t = 1 + (1<<(16+l))/d;
157 *quant = (short)(t - (1<<16));
158 *shift = l;
159 }
160
vp8cx_init_quantizer(VP8_COMP * cpi)161 void vp8cx_init_quantizer(VP8_COMP *cpi)
162 {
163 int i;
164 int quant_val;
165 int Q;
166
167 int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};
168
169 for (Q = 0; Q < QINDEX_RANGE; Q++)
170 {
171 // dc values
172 quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);
173 vp8cx_invert_quant(cpi->Y1quant[Q] + 0,
174 cpi->Y1quant_shift[Q] + 0, quant_val);
175 cpi->Y1zbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
176 cpi->Y1round[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;
177 cpi->common.Y1dequant[Q][0] = quant_val;
178 cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;
179
180 quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);
181 vp8cx_invert_quant(cpi->Y2quant[Q] + 0,
182 cpi->Y2quant_shift[Q] + 0, quant_val);
183 cpi->Y2zbin[Q][0] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
184 cpi->Y2round[Q][0] = (qrounding_factors_y2[Q] * quant_val) >> 7;
185 cpi->common.Y2dequant[Q][0] = quant_val;
186 cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;
187
188 quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);
189 vp8cx_invert_quant(cpi->UVquant[Q] + 0,
190 cpi->UVquant_shift[Q] + 0, quant_val);
191 cpi->UVzbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;
192 cpi->UVround[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;
193 cpi->common.UVdequant[Q][0] = quant_val;
194 cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;
195
196 // all the ac values = ;
197 for (i = 1; i < 16; i++)
198 {
199 int rc = vp8_default_zig_zag1d[i];
200
201 quant_val = vp8_ac_yquant(Q);
202 vp8cx_invert_quant(cpi->Y1quant[Q] + rc,
203 cpi->Y1quant_shift[Q] + rc, quant_val);
204 cpi->Y1zbin[Q][rc] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
205 cpi->Y1round[Q][rc] = (qrounding_factors[Q] * quant_val) >> 7;
206 cpi->common.Y1dequant[Q][rc] = quant_val;
207 cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;
208
209 quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);
210 vp8cx_invert_quant(cpi->Y2quant[Q] + rc,
211 cpi->Y2quant_shift[Q] + rc, quant_val);
212 cpi->Y2zbin[Q][rc] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
213 cpi->Y2round[Q][rc] = (qrounding_factors_y2[Q] * quant_val) >> 7;
214 cpi->common.Y2dequant[Q][rc] = quant_val;
215 cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;
216
217 quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);
218 vp8cx_invert_quant(cpi->UVquant[Q] + rc,
219 cpi->UVquant_shift[Q] + rc, quant_val);
220 cpi->UVzbin[Q][rc] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
221 cpi->UVround[Q][rc] = (qrounding_factors[Q] * quant_val) >> 7;
222 cpi->common.UVdequant[Q][rc] = quant_val;
223 cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;
224 }
225 }
226 }
227 #else
vp8cx_init_quantizer(VP8_COMP * cpi)228 void vp8cx_init_quantizer(VP8_COMP *cpi)
229 {
230 int i;
231 int quant_val;
232 int Q;
233
234 int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};
235
236 for (Q = 0; Q < QINDEX_RANGE; Q++)
237 {
238 // dc values
239 quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);
240 cpi->Y1quant[Q][0] = (1 << 16) / quant_val;
241 cpi->Y1zbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
242 cpi->Y1round[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;
243 cpi->common.Y1dequant[Q][0] = quant_val;
244 cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;
245
246 quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);
247 cpi->Y2quant[Q][0] = (1 << 16) / quant_val;
248 cpi->Y2zbin[Q][0] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
249 cpi->Y2round[Q][0] = (qrounding_factors_y2[Q] * quant_val) >> 7;
250 cpi->common.Y2dequant[Q][0] = quant_val;
251 cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;
252
253 quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);
254 cpi->UVquant[Q][0] = (1 << 16) / quant_val;
255 cpi->UVzbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;
256 cpi->UVround[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;
257 cpi->common.UVdequant[Q][0] = quant_val;
258 cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;
259
260 // all the ac values = ;
261 for (i = 1; i < 16; i++)
262 {
263 int rc = vp8_default_zig_zag1d[i];
264
265 quant_val = vp8_ac_yquant(Q);
266 cpi->Y1quant[Q][rc] = (1 << 16) / quant_val;
267 cpi->Y1zbin[Q][rc] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
268 cpi->Y1round[Q][rc] = (qrounding_factors[Q] * quant_val) >> 7;
269 cpi->common.Y1dequant[Q][rc] = quant_val;
270 cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;
271
272 quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);
273 cpi->Y2quant[Q][rc] = (1 << 16) / quant_val;
274 cpi->Y2zbin[Q][rc] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
275 cpi->Y2round[Q][rc] = (qrounding_factors_y2[Q] * quant_val) >> 7;
276 cpi->common.Y2dequant[Q][rc] = quant_val;
277 cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;
278
279 quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);
280 cpi->UVquant[Q][rc] = (1 << 16) / quant_val;
281 cpi->UVzbin[Q][rc] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
282 cpi->UVround[Q][rc] = (qrounding_factors[Q] * quant_val) >> 7;
283 cpi->common.UVdequant[Q][rc] = quant_val;
284 cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;
285 }
286 }
287 }
288 #endif
vp8cx_mb_init_quantizer(VP8_COMP * cpi,MACROBLOCK * x)289 void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x)
290 {
291 int i;
292 int QIndex;
293 MACROBLOCKD *xd = &x->e_mbd;
294 int zbin_extra;
295
296 // Select the baseline MB Q index.
297 if (xd->segmentation_enabled)
298 {
299 // Abs Value
300 if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
301
302 QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context->mbmi.segment_id];
303 // Delta Value
304 else
305 {
306 QIndex = cpi->common.base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context->mbmi.segment_id];
307 QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0; // Clamp to valid range
308 }
309 }
310 else
311 QIndex = cpi->common.base_qindex;
312
313 // Y
314 zbin_extra = (cpi->common.Y1dequant[QIndex][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
315
316 for (i = 0; i < 16; i++)
317 {
318 x->block[i].quant = cpi->Y1quant[QIndex];
319 x->block[i].quant_shift = cpi->Y1quant_shift[QIndex];
320 x->block[i].zbin = cpi->Y1zbin[QIndex];
321 x->block[i].round = cpi->Y1round[QIndex];
322 x->e_mbd.block[i].dequant = cpi->common.Y1dequant[QIndex];
323 x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex];
324 x->block[i].zbin_extra = (short)zbin_extra;
325 }
326
327 // UV
328 zbin_extra = (cpi->common.UVdequant[QIndex][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
329
330 for (i = 16; i < 24; i++)
331 {
332 x->block[i].quant = cpi->UVquant[QIndex];
333 x->block[i].quant_shift = cpi->UVquant_shift[QIndex];
334 x->block[i].zbin = cpi->UVzbin[QIndex];
335 x->block[i].round = cpi->UVround[QIndex];
336 x->e_mbd.block[i].dequant = cpi->common.UVdequant[QIndex];
337 x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex];
338 x->block[i].zbin_extra = (short)zbin_extra;
339 }
340
341 // Y2
342 zbin_extra = (cpi->common.Y2dequant[QIndex][1] * ((cpi->zbin_over_quant / 2) + cpi->zbin_mode_boost)) >> 7;
343 x->block[24].quant = cpi->Y2quant[QIndex];
344 x->block[24].quant_shift = cpi->Y2quant_shift[QIndex];
345 x->block[24].zbin = cpi->Y2zbin[QIndex];
346 x->block[24].round = cpi->Y2round[QIndex];
347 x->e_mbd.block[24].dequant = cpi->common.Y2dequant[QIndex];
348 x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex];
349 x->block[24].zbin_extra = (short)zbin_extra;
350 }
351
vp8cx_frame_init_quantizer(VP8_COMP * cpi)352 void vp8cx_frame_init_quantizer(VP8_COMP *cpi)
353 {
354 // vp8cx_init_quantizer() is first called in vp8_create_compressor(). A check is added here so that vp8cx_init_quantizer() is only called
355 // when these values are not all zero.
356 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)
357 {
358 vp8cx_init_quantizer(cpi);
359 }
360
361 // MB level quantizer setup
362 vp8cx_mb_init_quantizer(cpi, &cpi->mb);
363 }
364
365
366
367 static
encode_mb_row(VP8_COMP * cpi,VP8_COMMON * cm,int mb_row,MACROBLOCK * x,MACROBLOCKD * xd,TOKENEXTRA ** tp,int * segment_counts,int * totalrate)368 void encode_mb_row(VP8_COMP *cpi,
369 VP8_COMMON *cm,
370 int mb_row,
371 MACROBLOCK *x,
372 MACROBLOCKD *xd,
373 TOKENEXTRA **tp,
374 int *segment_counts,
375 int *totalrate)
376 {
377 int i;
378 int recon_yoffset, recon_uvoffset;
379 int mb_col;
380 int ref_fb_idx = cm->lst_fb_idx;
381 int dst_fb_idx = cm->new_fb_idx;
382 int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
383 int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
384 int seg_map_index = (mb_row * cpi->common.mb_cols);
385
386
387 // reset above block coeffs
388 xd->above_context = cm->above_context;
389
390 xd->up_available = (mb_row != 0);
391 recon_yoffset = (mb_row * recon_y_stride * 16);
392 recon_uvoffset = (mb_row * recon_uv_stride * 8);
393
394 cpi->tplist[mb_row].start = *tp;
395 //printf("Main mb_row = %d\n", mb_row);
396
397 // Distance of Mb to the top & bottom edges, specified in 1/8th pel
398 // units as they are always compared to values that are in 1/8th pel units
399 xd->mb_to_top_edge = -((mb_row * 16) << 3);
400 xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
401
402 // Set up limit values for vertical motion vector components
403 // to prevent them extending beyond the UMV borders
404 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
405 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
406 + (VP8BORDERINPIXELS - 16);
407
408 // for each macroblock col in image
409 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
410 {
411 // Distance of Mb to the left & right edges, specified in
412 // 1/8th pel units as they are always compared to values
413 // that are in 1/8th pel units
414 xd->mb_to_left_edge = -((mb_col * 16) << 3);
415 xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
416
417 // Set up limit values for horizontal motion vector components
418 // to prevent them extending beyond the UMV borders
419 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
420 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16)
421 + (VP8BORDERINPIXELS - 16);
422
423 xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
424 xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
425 xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
426 xd->left_available = (mb_col != 0);
427
428 // Is segmentation enabled
429 // MB level adjutment to quantizer
430 if (xd->segmentation_enabled)
431 {
432 // Code to set segment id in xd->mbmi.segment_id for current MB (with range checking)
433 if (cpi->segmentation_map[seg_map_index+mb_col] <= 3)
434 xd->mode_info_context->mbmi.segment_id = cpi->segmentation_map[seg_map_index+mb_col];
435 else
436 xd->mode_info_context->mbmi.segment_id = 0;
437
438 vp8cx_mb_init_quantizer(cpi, x);
439 }
440 else
441 xd->mode_info_context->mbmi.segment_id = 0; // Set to Segment 0 by default
442
443 x->active_ptr = cpi->active_map + seg_map_index + mb_col;
444
445 if (cm->frame_type == KEY_FRAME)
446 {
447 *totalrate += vp8cx_encode_intra_macro_block(cpi, x, tp);
448 #ifdef MODE_STATS
449 y_modes[xd->mbmi.mode] ++;
450 #endif
451 }
452 else
453 {
454 *totalrate += vp8cx_encode_inter_macroblock(cpi, x, tp, recon_yoffset, recon_uvoffset);
455
456 #ifdef MODE_STATS
457 inter_y_modes[xd->mbmi.mode] ++;
458
459 if (xd->mbmi.mode == SPLITMV)
460 {
461 int b;
462
463 for (b = 0; b < xd->mbmi.partition_count; b++)
464 {
465 inter_b_modes[x->partition->bmi[b].mode] ++;
466 }
467 }
468
469 #endif
470
471 // Count of last ref frame 0,0 useage
472 if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
473 cpi->inter_zz_count ++;
474
475 // Special case code for cyclic refresh
476 // If cyclic update enabled then copy xd->mbmi.segment_id; (which may have been updated based on mode
477 // during vp8cx_encode_inter_macroblock()) back into the global sgmentation map
478 if (cpi->cyclic_refresh_mode_enabled && xd->segmentation_enabled)
479 {
480 cpi->segmentation_map[seg_map_index+mb_col] = xd->mode_info_context->mbmi.segment_id;
481
482 // 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):
483 // 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)
484 // else mark it as dirty (1).
485 if (xd->mode_info_context->mbmi.segment_id)
486 cpi->cyclic_refresh_map[seg_map_index+mb_col] = -1;
487 else if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
488 {
489 if (cpi->cyclic_refresh_map[seg_map_index+mb_col] == 1)
490 cpi->cyclic_refresh_map[seg_map_index+mb_col] = 0;
491 }
492 else
493 cpi->cyclic_refresh_map[seg_map_index+mb_col] = 1;
494
495 }
496 }
497
498 cpi->tplist[mb_row].stop = *tp;
499
500 x->gf_active_ptr++; // Increment pointer into gf useage flags structure for next mb
501
502 for (i = 0; i < 16; i++)
503 vpx_memcpy(&xd->mode_info_context->bmi[i], &xd->block[i].bmi, sizeof(xd->block[i].bmi));
504
505 // adjust to the next column of macroblocks
506 x->src.y_buffer += 16;
507 x->src.u_buffer += 8;
508 x->src.v_buffer += 8;
509
510 recon_yoffset += 16;
511 recon_uvoffset += 8;
512
513 // Keep track of segment useage
514 segment_counts[xd->mode_info_context->mbmi.segment_id] ++;
515
516 // skip to next mb
517 xd->mode_info_context++;
518 x->partition_info++;
519
520 xd->above_context++;
521 cpi->current_mb_col_main = mb_col;
522 }
523
524 //extend the recon for intra prediction
525 vp8_extend_mb_row(
526 &cm->yv12_fb[dst_fb_idx],
527 xd->dst.y_buffer + 16,
528 xd->dst.u_buffer + 8,
529 xd->dst.v_buffer + 8);
530
531 // this is to account for the border
532 xd->mode_info_context++;
533 x->partition_info++;
534 }
535
536
537
538
539
vp8_encode_frame(VP8_COMP * cpi)540 void vp8_encode_frame(VP8_COMP *cpi)
541 {
542 int mb_row;
543 MACROBLOCK *const x = & cpi->mb;
544 VP8_COMMON *const cm = & cpi->common;
545 MACROBLOCKD *const xd = & x->e_mbd;
546
547 int i;
548 TOKENEXTRA *tp = cpi->tok;
549 int segment_counts[MAX_MB_SEGMENTS];
550 int totalrate;
551
552 // Functions setup for all frame types so we can use MC in AltRef
553 if (cm->mcomp_filter_type == SIXTAP)
554 {
555 xd->subpixel_predict = SUBPIX_INVOKE(
556 &cpi->common.rtcd.subpix, sixtap4x4);
557 xd->subpixel_predict8x4 = SUBPIX_INVOKE(
558 &cpi->common.rtcd.subpix, sixtap8x4);
559 xd->subpixel_predict8x8 = SUBPIX_INVOKE(
560 &cpi->common.rtcd.subpix, sixtap8x8);
561 xd->subpixel_predict16x16 = SUBPIX_INVOKE(
562 &cpi->common.rtcd.subpix, sixtap16x16);
563 }
564 else
565 {
566 xd->subpixel_predict = SUBPIX_INVOKE(
567 &cpi->common.rtcd.subpix, bilinear4x4);
568 xd->subpixel_predict8x4 = SUBPIX_INVOKE(
569 &cpi->common.rtcd.subpix, bilinear8x4);
570 xd->subpixel_predict8x8 = SUBPIX_INVOKE(
571 &cpi->common.rtcd.subpix, bilinear8x8);
572 xd->subpixel_predict16x16 = SUBPIX_INVOKE(
573 &cpi->common.rtcd.subpix, bilinear16x16);
574 }
575
576 x->gf_active_ptr = (signed char *)cpi->gf_active_flags; // Point to base of GF active flags data structure
577
578 x->vector_range = 32;
579
580 // Count of MBs using the alternate Q if any
581 cpi->alt_qcount = 0;
582
583 // Reset frame count of inter 0,0 motion vector useage.
584 cpi->inter_zz_count = 0;
585
586 vpx_memset(segment_counts, 0, sizeof(segment_counts));
587
588 cpi->prediction_error = 0;
589 cpi->intra_error = 0;
590 cpi->skip_true_count = 0;
591 cpi->skip_false_count = 0;
592
593 #if 0
594 // Experimental code
595 cpi->frame_distortion = 0;
596 cpi->last_mb_distortion = 0;
597 #endif
598
599 totalrate = 0;
600
601 x->partition_info = x->pi;
602
603 xd->mode_info_context = cm->mi;
604 xd->mode_info_stride = cm->mode_info_stride;
605
606 xd->frame_type = cm->frame_type;
607
608 xd->frames_since_golden = cm->frames_since_golden;
609 xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
610 vp8_zero(cpi->MVcount);
611 // vp8_zero( Contexts)
612 vp8_zero(cpi->coef_counts);
613
614 // reset intra mode contexts
615 if (cm->frame_type == KEY_FRAME)
616 vp8_init_mbmode_probs(cm);
617
618
619 vp8cx_frame_init_quantizer(cpi);
620
621 if (cpi->compressor_speed == 2)
622 {
623 if (cpi->oxcf.cpu_used < 0)
624 cpi->Speed = -(cpi->oxcf.cpu_used);
625 else
626 vp8_auto_select_speed(cpi);
627 }
628
629 vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
630 //vp8_initialize_rd_consts( cpi, vp8_dc_quant(cpi->avg_frame_qindex, cm->y1dc_delta_q) );
631 vp8cx_initialize_me_consts(cpi, cm->base_qindex);
632 //vp8cx_initialize_me_consts( cpi, cpi->avg_frame_qindex);
633
634 // Copy data over into macro block data sturctures.
635
636 x->src = * cpi->Source;
637 xd->pre = cm->yv12_fb[cm->lst_fb_idx];
638 xd->dst = cm->yv12_fb[cm->new_fb_idx];
639
640 // set up frame new frame for intra coded blocks
641
642 vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
643
644 vp8_build_block_offsets(x);
645
646 vp8_setup_block_dptrs(&x->e_mbd);
647
648 vp8_setup_block_ptrs(x);
649
650 x->rddiv = cpi->RDDIV;
651 x->rdmult = cpi->RDMULT;
652
653 #if 0
654 // Experimental rd code
655 // 2 Pass - Possibly set Rdmult based on last frame distortion + this frame target bits or other metrics
656 // such as cpi->rate_correction_factor that indicate relative complexity.
657 /*if ( cpi->pass == 2 && (cpi->last_frame_distortion > 0) && (cpi->target_bits_per_mb > 0) )
658 {
659 //x->rdmult = ((cpi->last_frame_distortion * 256)/cpi->common.MBs)/ cpi->target_bits_per_mb;
660 x->rdmult = (int)(cpi->RDMULT * cpi->rate_correction_factor);
661 }
662 else
663 x->rdmult = cpi->RDMULT; */
664 //x->rdmult = (int)(cpi->RDMULT * pow( (cpi->rate_correction_factor * 2.0), 0.75 ));
665 #endif
666
667 xd->mode_info_context->mbmi.mode = DC_PRED;
668 xd->mode_info_context->mbmi.uv_mode = DC_PRED;
669
670 xd->left_context = &cm->left_context;
671
672 vp8_zero(cpi->count_mb_ref_frame_usage)
673 vp8_zero(cpi->ymode_count)
674 vp8_zero(cpi->uv_mode_count)
675
676 x->mvc = cm->fc.mvc;
677
678 vpx_memset(cm->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
679
680 {
681 struct vpx_usec_timer emr_timer;
682 vpx_usec_timer_start(&emr_timer);
683
684 if (!cpi->b_multi_threaded)
685 {
686 // for each macroblock row in image
687 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
688 {
689
690 vp8_zero(cm->left_context)
691
692 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
693
694 // adjust to the next row of mbs
695 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
696 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
697 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
698 }
699
700 cpi->tok_count = tp - cpi->tok;
701
702 }
703 else
704 {
705 #if CONFIG_MULTITHREAD
706 vp8cx_init_mbrthread_data(cpi, x, cpi->mb_row_ei, 1, cpi->encoding_thread_count);
707
708 for (mb_row = 0; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
709 {
710 int i;
711 cpi->current_mb_col_main = -1;
712
713 for (i = 0; i < cpi->encoding_thread_count; i++)
714 {
715 if ((mb_row + i + 1) >= cm->mb_rows)
716 break;
717
718 cpi->mb_row_ei[i].mb_row = mb_row + i + 1;
719 cpi->mb_row_ei[i].tp = cpi->tok + (mb_row + i + 1) * (cm->mb_cols * 16 * 24);
720 cpi->mb_row_ei[i].current_mb_col = -1;
721 //SetEvent(cpi->h_event_mbrencoding[i]);
722 sem_post(&cpi->h_event_mbrencoding[i]);
723 }
724
725 vp8_zero(cm->left_context)
726
727 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
728
729 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
730
731 // adjust to the next row of mbs
732 x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
733 x->src.u_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
734 x->src.v_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
735
736 xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
737 x->partition_info += xd->mode_info_stride * cpi->encoding_thread_count;
738
739 if (mb_row < cm->mb_rows - 1)
740 //WaitForSingleObject(cpi->h_event_main, INFINITE);
741 sem_wait(&cpi->h_event_main);
742 }
743
744 /*
745 for( ;mb_row<cm->mb_rows; mb_row ++)
746 {
747 vp8_zero( cm->left_context)
748
749 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
750
751 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
752 // adjust to the next row of mbs
753 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
754 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
755 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
756
757 }
758 */
759 cpi->tok_count = 0;
760
761 for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
762 {
763 cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
764 }
765
766 if (xd->segmentation_enabled)
767 {
768
769 int i, j;
770
771 if (xd->segmentation_enabled)
772 {
773
774 for (i = 0; i < cpi->encoding_thread_count; i++)
775 {
776 for (j = 0; j < 4; j++)
777 segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
778 }
779 }
780
781 }
782
783 for (i = 0; i < cpi->encoding_thread_count; i++)
784 {
785 totalrate += cpi->mb_row_ei[i].totalrate;
786 }
787
788 #endif
789
790 }
791
792 vpx_usec_timer_mark(&emr_timer);
793 cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
794
795 }
796
797
798 // Work out the segment probabilites if segmentation is enabled
799 if (xd->segmentation_enabled)
800 {
801 int tot_count;
802 int i;
803
804 // Set to defaults
805 vpx_memset(xd->mb_segment_tree_probs, 255 , sizeof(xd->mb_segment_tree_probs));
806
807 tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
808
809 if (tot_count)
810 {
811 xd->mb_segment_tree_probs[0] = ((segment_counts[0] + segment_counts[1]) * 255) / tot_count;
812
813 tot_count = segment_counts[0] + segment_counts[1];
814
815 if (tot_count > 0)
816 {
817 xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) / tot_count;
818 }
819
820 tot_count = segment_counts[2] + segment_counts[3];
821
822 if (tot_count > 0)
823 xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) / tot_count;
824
825 // Zero probabilities not allowed
826 for (i = 0; i < MB_FEATURE_TREE_PROBS; i ++)
827 {
828 if (xd->mb_segment_tree_probs[i] == 0)
829 xd->mb_segment_tree_probs[i] = 1;
830 }
831 }
832 }
833
834 // 256 rate units to the bit
835 cpi->projected_frame_size = totalrate >> 8; // projected_frame_size in units of BYTES
836
837 // Make a note of the percentage MBs coded Intra.
838 if (cm->frame_type == KEY_FRAME)
839 {
840 cpi->this_frame_percent_intra = 100;
841 }
842 else
843 {
844 int tot_modes;
845
846 tot_modes = cpi->count_mb_ref_frame_usage[INTRA_FRAME]
847 + cpi->count_mb_ref_frame_usage[LAST_FRAME]
848 + cpi->count_mb_ref_frame_usage[GOLDEN_FRAME]
849 + cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
850
851 if (tot_modes)
852 cpi->this_frame_percent_intra = cpi->count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;
853
854 }
855
856 #if 0
857 {
858 int cnt = 0;
859 int flag[2] = {0, 0};
860
861 for (cnt = 0; cnt < MVPcount; cnt++)
862 {
863 if (cm->fc.pre_mvc[0][cnt] != cm->fc.mvc[0][cnt])
864 {
865 flag[0] = 1;
866 vpx_memcpy(cm->fc.pre_mvc[0], cm->fc.mvc[0], MVPcount);
867 break;
868 }
869 }
870
871 for (cnt = 0; cnt < MVPcount; cnt++)
872 {
873 if (cm->fc.pre_mvc[1][cnt] != cm->fc.mvc[1][cnt])
874 {
875 flag[1] = 1;
876 vpx_memcpy(cm->fc.pre_mvc[1], cm->fc.mvc[1], MVPcount);
877 break;
878 }
879 }
880
881 if (flag[0] || flag[1])
882 vp8_build_component_cost_table(cpi->mb.mvcost, cpi->mb.mvsadcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
883 }
884 #endif
885
886 // Adjust the projected reference frame useage probability numbers to reflect
887 // what we have just seen. This may be usefull when we make multiple itterations
888 // of the recode loop rather than continuing to use values from the previous frame.
889 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_alt_ref_frame && !cm->refresh_golden_frame)
890 {
891 const int *const rfct = cpi->count_mb_ref_frame_usage;
892 const int rf_intra = rfct[INTRA_FRAME];
893 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
894
895 if ((rf_intra + rf_inter) > 0)
896 {
897 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
898
899 if (cpi->prob_intra_coded < 1)
900 cpi->prob_intra_coded = 1;
901
902 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
903 {
904 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
905
906 if (cpi->prob_last_coded < 1)
907 cpi->prob_last_coded = 1;
908
909 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
910 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
911
912 if (cpi->prob_gf_coded < 1)
913 cpi->prob_gf_coded = 1;
914 }
915 }
916 }
917
918 #if 0
919 // Keep record of the total distortion this time around for future use
920 cpi->last_frame_distortion = cpi->frame_distortion;
921 #endif
922
923 }
vp8_setup_block_ptrs(MACROBLOCK * x)924 void vp8_setup_block_ptrs(MACROBLOCK *x)
925 {
926 int r, c;
927 int i;
928
929 for (r = 0; r < 4; r++)
930 {
931 for (c = 0; c < 4; c++)
932 {
933 x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
934 }
935 }
936
937 for (r = 0; r < 2; r++)
938 {
939 for (c = 0; c < 2; c++)
940 {
941 x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
942 }
943 }
944
945
946 for (r = 0; r < 2; r++)
947 {
948 for (c = 0; c < 2; c++)
949 {
950 x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
951 }
952 }
953
954 x->block[24].src_diff = x->src_diff + 384;
955
956
957 for (i = 0; i < 25; i++)
958 {
959 x->block[i].coeff = x->coeff + i * 16;
960 }
961 }
962
vp8_build_block_offsets(MACROBLOCK * x)963 void vp8_build_block_offsets(MACROBLOCK *x)
964 {
965 int block = 0;
966 int br, bc;
967
968 vp8_build_block_doffsets(&x->e_mbd);
969
970 // y blocks
971 for (br = 0; br < 4; br++)
972 {
973 for (bc = 0; bc < 4; bc++)
974 {
975 BLOCK *this_block = &x->block[block];
976 this_block->base_src = &x->src.y_buffer;
977 this_block->src_stride = x->src.y_stride;
978 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
979 ++block;
980 }
981 }
982
983 // u blocks
984 for (br = 0; br < 2; br++)
985 {
986 for (bc = 0; bc < 2; bc++)
987 {
988 BLOCK *this_block = &x->block[block];
989 this_block->base_src = &x->src.u_buffer;
990 this_block->src_stride = x->src.uv_stride;
991 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
992 ++block;
993 }
994 }
995
996 // v blocks
997 for (br = 0; br < 2; br++)
998 {
999 for (bc = 0; bc < 2; bc++)
1000 {
1001 BLOCK *this_block = &x->block[block];
1002 this_block->base_src = &x->src.v_buffer;
1003 this_block->src_stride = x->src.uv_stride;
1004 this_block->src = 4 * br * this_block->src_stride + 4 * bc;
1005 ++block;
1006 }
1007 }
1008 }
1009
sum_intra_stats(VP8_COMP * cpi,MACROBLOCK * x)1010 static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x)
1011 {
1012 const MACROBLOCKD *xd = & x->e_mbd;
1013 const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi.mode;
1014 const MB_PREDICTION_MODE uvm = xd->mode_info_context->mbmi.uv_mode;
1015
1016 #ifdef MODE_STATS
1017 const int is_key = cpi->common.frame_type == KEY_FRAME;
1018
1019 ++ (is_key ? uv_modes : inter_uv_modes)[uvm];
1020
1021 if (m == B_PRED)
1022 {
1023 unsigned int *const bct = is_key ? b_modes : inter_b_modes;
1024
1025 int b = 0;
1026
1027 do
1028 {
1029 ++ bct[xd->block[b].bmi.mode];
1030 }
1031 while (++b < 16);
1032 }
1033
1034 #endif
1035
1036 ++cpi->ymode_count[m];
1037 ++cpi->uv_mode_count[uvm];
1038
1039 }
vp8cx_encode_intra_macro_block(VP8_COMP * cpi,MACROBLOCK * x,TOKENEXTRA ** t)1040 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t)
1041 {
1042 int Error4x4, Error16x16, error_uv;
1043 B_PREDICTION_MODE intra_bmodes[16];
1044 int rate4x4, rate16x16, rateuv;
1045 int dist4x4, dist16x16, distuv;
1046 int rate = 0;
1047 int rate4x4_tokenonly = 0;
1048 int rate16x16_tokenonly = 0;
1049 int rateuv_tokenonly = 0;
1050 int i;
1051
1052 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1053
1054 #if !(CONFIG_REALTIME_ONLY)
1055
1056 if (cpi->sf.RD || cpi->compressor_speed != 2)
1057 {
1058 Error4x4 = vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate4x4, &rate4x4_tokenonly, &dist4x4);
1059
1060 //save the b modes for possible later use
1061 for (i = 0; i < 16; i++)
1062 intra_bmodes[i] = x->e_mbd.block[i].bmi.mode;
1063
1064 Error16x16 = vp8_rd_pick_intra16x16mby_mode(cpi, x, &rate16x16, &rate16x16_tokenonly, &dist16x16);
1065
1066 error_uv = vp8_rd_pick_intra_mbuv_mode(cpi, x, &rateuv, &rateuv_tokenonly, &distuv);
1067
1068 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1069 rate += rateuv;
1070
1071 if (Error4x4 < Error16x16)
1072 {
1073 rate += rate4x4;
1074 x->e_mbd.mode_info_context->mbmi.mode = B_PRED;
1075
1076 // get back the intra block modes
1077 for (i = 0; i < 16; i++)
1078 x->e_mbd.block[i].bmi.mode = intra_bmodes[i];
1079
1080 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1081 cpi->prediction_error += Error4x4 ;
1082 #if 0
1083 // Experimental RD code
1084 cpi->frame_distortion += dist4x4;
1085 #endif
1086 }
1087 else
1088 {
1089 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1090 rate += rate16x16;
1091
1092 #if 0
1093 // Experimental RD code
1094 cpi->prediction_error += Error16x16;
1095 cpi->frame_distortion += dist16x16;
1096 #endif
1097 }
1098
1099 sum_intra_stats(cpi, x);
1100
1101 vp8_tokenize_mb(cpi, &x->e_mbd, t);
1102 }
1103 else
1104 #endif
1105 {
1106
1107 int rate2, distortion2;
1108 MB_PREDICTION_MODE mode, best_mode = DC_PRED;
1109 int this_rd;
1110 Error16x16 = INT_MAX;
1111
1112 for (mode = DC_PRED; mode <= TM_PRED; mode ++)
1113 {
1114 x->e_mbd.mode_info_context->mbmi.mode = mode;
1115 vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
1116 distortion2 = VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16prederror)(x->src.y_buffer, x->src.y_stride, x->e_mbd.predictor, 16, 0x7fffffff);
1117 rate2 = x->mbmode_cost[x->e_mbd.frame_type][mode];
1118 this_rd = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1119
1120 if (Error16x16 > this_rd)
1121 {
1122 Error16x16 = this_rd;
1123 best_mode = mode;
1124 }
1125 }
1126
1127 vp8_pick_intra4x4mby_modes(IF_RTCD(&cpi->rtcd), x, &rate2, &distortion2);
1128
1129 if (distortion2 == INT_MAX)
1130 Error4x4 = INT_MAX;
1131 else
1132 Error4x4 = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1133
1134 if (Error4x4 < Error16x16)
1135 {
1136 x->e_mbd.mode_info_context->mbmi.mode = B_PRED;
1137 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1138 cpi->prediction_error += Error4x4;
1139 }
1140 else
1141 {
1142 x->e_mbd.mode_info_context->mbmi.mode = best_mode;
1143 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1144 cpi->prediction_error += Error16x16;
1145 }
1146
1147 vp8_pick_intra_mbuv_mode(x);
1148 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1149 sum_intra_stats(cpi, x);
1150 vp8_tokenize_mb(cpi, &x->e_mbd, t);
1151 }
1152
1153 return rate;
1154 }
1155 #ifdef SPEEDSTATS
1156 extern int cnt_pm;
1157 #endif
1158
1159 extern void vp8_fix_contexts(MACROBLOCKD *x);
1160
vp8cx_encode_inter_macroblock(VP8_COMP * cpi,MACROBLOCK * x,TOKENEXTRA ** t,int recon_yoffset,int recon_uvoffset)1161 int vp8cx_encode_inter_macroblock
1162 (
1163 VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
1164 int recon_yoffset, int recon_uvoffset
1165 )
1166 {
1167 MACROBLOCKD *const xd = &x->e_mbd;
1168 int inter_error;
1169 int intra_error = 0;
1170 int rate;
1171 int distortion;
1172
1173 x->skip = 0;
1174
1175 if (xd->segmentation_enabled)
1176 x->encode_breakout = cpi->segment_encode_breakout[xd->mode_info_context->mbmi.segment_id];
1177 else
1178 x->encode_breakout = cpi->oxcf.encode_breakout;
1179
1180 #if !(CONFIG_REALTIME_ONLY)
1181
1182 if (cpi->sf.RD)
1183 {
1184 inter_error = vp8_rd_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1185 }
1186 else
1187 #endif
1188 inter_error = vp8_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1189
1190
1191 cpi->prediction_error += inter_error;
1192 cpi->intra_error += intra_error;
1193
1194 #if 0
1195 // Experimental RD code
1196 cpi->frame_distortion += distortion;
1197 cpi->last_mb_distortion = distortion;
1198 #endif
1199
1200 // MB level adjutment to quantizer setup
1201 if (xd->segmentation_enabled || cpi->zbin_mode_boost_enabled)
1202 {
1203 // If cyclic update enabled
1204 if (cpi->cyclic_refresh_mode_enabled)
1205 {
1206 // Clear segment_id back to 0 if not coded (last frame 0,0)
1207 if ((xd->mode_info_context->mbmi.segment_id == 1) &&
1208 ((xd->mode_info_context->mbmi.ref_frame != LAST_FRAME) || (xd->mode_info_context->mbmi.mode != ZEROMV)))
1209 {
1210 xd->mode_info_context->mbmi.segment_id = 0;
1211 }
1212 }
1213
1214 // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1215 if (cpi->zbin_mode_boost_enabled)
1216 {
1217 if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame != LAST_FRAME))
1218 cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1219 else
1220 cpi->zbin_mode_boost = 0;
1221 }
1222
1223 vp8cx_mb_init_quantizer(cpi, x);
1224 }
1225
1226 cpi->count_mb_ref_frame_usage[xd->mode_info_context->mbmi.ref_frame] ++;
1227
1228 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
1229 {
1230 vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1231
1232 if (xd->mode_info_context->mbmi.mode == B_PRED)
1233 {
1234 vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1235 }
1236 else
1237 {
1238 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1239 }
1240
1241 sum_intra_stats(cpi, x);
1242 }
1243 else
1244 {
1245 MV best_ref_mv;
1246 MV nearest, nearby;
1247 int mdcounts[4];
1248 int ref_fb_idx;
1249
1250 vp8_find_near_mvs(xd, xd->mode_info_context,
1251 &nearest, &nearby, &best_ref_mv, mdcounts, xd->mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias);
1252
1253 vp8_build_uvmvs(xd, cpi->common.full_pixel);
1254
1255 if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
1256 ref_fb_idx = cpi->common.lst_fb_idx;
1257 else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
1258 ref_fb_idx = cpi->common.gld_fb_idx;
1259 else
1260 ref_fb_idx = cpi->common.alt_fb_idx;
1261
1262 xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
1263 xd->pre.u_buffer = cpi->common.yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
1264 xd->pre.v_buffer = cpi->common.yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
1265
1266 if (xd->mode_info_context->mbmi.mode == SPLITMV)
1267 {
1268 int i;
1269
1270 for (i = 0; i < 16; i++)
1271 {
1272 if (xd->block[i].bmi.mode == NEW4X4)
1273 {
1274 cpi->MVcount[0][mv_max+((xd->block[i].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1275 cpi->MVcount[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1276 }
1277 }
1278 }
1279 else if (xd->mode_info_context->mbmi.mode == NEWMV)
1280 {
1281 cpi->MVcount[0][mv_max+((xd->block[0].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1282 cpi->MVcount[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1283 }
1284
1285 if (!x->skip && !x->e_mbd.mode_info_context->mbmi.force_no_skip)
1286 {
1287 vp8_encode_inter16x16(IF_RTCD(&cpi->rtcd), x);
1288
1289 // Clear mb_skip_coeff if mb_no_coeff_skip is not set
1290 if (!cpi->common.mb_no_coeff_skip)
1291 xd->mode_info_context->mbmi.mb_skip_coeff = 0;
1292
1293 }
1294 else
1295 vp8_stuff_inter16x16(x);
1296 }
1297
1298 if (!x->skip)
1299 vp8_tokenize_mb(cpi, xd, t);
1300 else
1301 {
1302 if (cpi->common.mb_no_coeff_skip)
1303 {
1304 if (xd->mode_info_context->mbmi.mode != B_PRED && xd->mode_info_context->mbmi.mode != SPLITMV)
1305 xd->mode_info_context->mbmi.dc_diff = 0;
1306 else
1307 xd->mode_info_context->mbmi.dc_diff = 1;
1308
1309 xd->mode_info_context->mbmi.mb_skip_coeff = 1;
1310 cpi->skip_true_count ++;
1311 vp8_fix_contexts(xd);
1312 }
1313 else
1314 {
1315 vp8_stuff_mb(cpi, xd, t);
1316 xd->mode_info_context->mbmi.mb_skip_coeff = 0;
1317 cpi->skip_false_count ++;
1318 }
1319 }
1320
1321 return rate;
1322 }
1323