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