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 #include "vp8/common/header.h" 12 #include "encodemv.h" 13 #include "vp8/common/entropymode.h" 14 #include "vp8/common/findnearmv.h" 15 #include "mcomp.h" 16 #include "vp8/common/systemdependent.h" 17 #include <assert.h> 18 #include <stdio.h> 19 #include <limits.h> 20 #include "vpx/vpx_encoder.h" 21 #include "vpx_mem/vpx_mem.h" 22 #include "vpx_ports/system_state.h" 23 #include "bitstream.h" 24 25 #include "defaultcoefcounts.h" 26 #include "vp8/common/common.h" 27 28 const int vp8cx_base_skip_false_prob[128] = { 29 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 30 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 31 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 32 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 251, 248, 244, 240, 33 236, 232, 229, 225, 221, 217, 213, 208, 204, 199, 194, 190, 187, 183, 179, 34 175, 172, 168, 164, 160, 157, 153, 149, 145, 142, 138, 134, 130, 127, 124, 35 120, 117, 114, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 36 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 37 30, 28, 26, 24, 22, 20, 18, 16, 38 }; 39 40 #if defined(SECTIONBITS_OUTPUT) 41 unsigned __int64 Sectionbits[500]; 42 #endif 43 44 #ifdef MODE_STATS 45 int count_mb_seg[4] = { 0, 0, 0, 0 }; 46 #endif 47 48 static void update_mode(vp8_writer *const w, int n, vp8_token tok[/* n */], 49 vp8_tree tree, vp8_prob Pnew[/* n-1 */], 50 vp8_prob Pcur[/* n-1 */], 51 unsigned int bct[/* n-1 */][2], 52 const unsigned int num_events[/* n */]) { 53 unsigned int new_b = 0, old_b = 0; 54 int i = 0; 55 56 vp8_tree_probs_from_distribution(n--, tok, tree, Pnew, bct, num_events, 256, 57 1); 58 59 do { 60 new_b += vp8_cost_branch(bct[i], Pnew[i]); 61 old_b += vp8_cost_branch(bct[i], Pcur[i]); 62 } while (++i < n); 63 64 if (new_b + (n << 8) < old_b) { 65 int j = 0; 66 67 vp8_write_bit(w, 1); 68 69 do { 70 const vp8_prob p = Pnew[j]; 71 72 vp8_write_literal(w, Pcur[j] = p ? p : 1, 8); 73 } while (++j < n); 74 } else 75 vp8_write_bit(w, 0); 76 } 77 78 static void update_mbintra_mode_probs(VP8_COMP *cpi) { 79 VP8_COMMON *const x = &cpi->common; 80 81 vp8_writer *const w = cpi->bc; 82 83 { 84 vp8_prob Pnew[VP8_YMODES - 1]; 85 unsigned int bct[VP8_YMODES - 1][2]; 86 87 update_mode(w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree, Pnew, 88 x->fc.ymode_prob, bct, (unsigned int *)cpi->mb.ymode_count); 89 } 90 { 91 vp8_prob Pnew[VP8_UV_MODES - 1]; 92 unsigned int bct[VP8_UV_MODES - 1][2]; 93 94 update_mode(w, VP8_UV_MODES, vp8_uv_mode_encodings, vp8_uv_mode_tree, Pnew, 95 x->fc.uv_mode_prob, bct, (unsigned int *)cpi->mb.uv_mode_count); 96 } 97 } 98 99 static void write_ymode(vp8_writer *bc, int m, const vp8_prob *p) { 100 vp8_write_token(bc, vp8_ymode_tree, p, vp8_ymode_encodings + m); 101 } 102 103 static void kfwrite_ymode(vp8_writer *bc, int m, const vp8_prob *p) { 104 vp8_write_token(bc, vp8_kf_ymode_tree, p, vp8_kf_ymode_encodings + m); 105 } 106 107 static void write_uv_mode(vp8_writer *bc, int m, const vp8_prob *p) { 108 vp8_write_token(bc, vp8_uv_mode_tree, p, vp8_uv_mode_encodings + m); 109 } 110 111 static void write_bmode(vp8_writer *bc, int m, const vp8_prob *p) { 112 vp8_write_token(bc, vp8_bmode_tree, p, vp8_bmode_encodings + m); 113 } 114 115 static void write_split(vp8_writer *bc, int x) { 116 vp8_write_token(bc, vp8_mbsplit_tree, vp8_mbsplit_probs, 117 vp8_mbsplit_encodings + x); 118 } 119 120 void vp8_pack_tokens(vp8_writer *w, const TOKENEXTRA *p, int xcount) { 121 const TOKENEXTRA *stop = p + xcount; 122 unsigned int split; 123 int shift; 124 int count = w->count; 125 unsigned int range = w->range; 126 unsigned int lowvalue = w->lowvalue; 127 128 while (p < stop) { 129 const int t = p->Token; 130 vp8_token *a = vp8_coef_encodings + t; 131 const vp8_extra_bit_struct *b = vp8_extra_bits + t; 132 int i = 0; 133 const unsigned char *pp = p->context_tree; 134 int v = a->value; 135 int n = a->Len; 136 137 if (p->skip_eob_node) { 138 n--; 139 i = 2; 140 } 141 142 do { 143 const int bb = (v >> --n) & 1; 144 split = 1 + (((range - 1) * pp[i >> 1]) >> 8); 145 i = vp8_coef_tree[i + bb]; 146 147 if (bb) { 148 lowvalue += split; 149 range = range - split; 150 } else { 151 range = split; 152 } 153 154 shift = vp8_norm[range]; 155 range <<= shift; 156 count += shift; 157 158 if (count >= 0) { 159 int offset = shift - count; 160 161 if ((lowvalue << (offset - 1)) & 0x80000000) { 162 int x = w->pos - 1; 163 164 while (x >= 0 && w->buffer[x] == 0xff) { 165 w->buffer[x] = (unsigned char)0; 166 x--; 167 } 168 169 w->buffer[x] += 1; 170 } 171 172 validate_buffer(w->buffer + w->pos, 1, w->buffer_end, w->error); 173 174 w->buffer[w->pos++] = (lowvalue >> (24 - offset)); 175 lowvalue <<= offset; 176 shift = count; 177 lowvalue &= 0xffffff; 178 count -= 8; 179 } 180 181 lowvalue <<= shift; 182 } while (n); 183 184 if (b->base_val) { 185 const int e = p->Extra, L = b->Len; 186 187 if (L) { 188 const unsigned char *proba = b->prob; 189 const int v2 = e >> 1; 190 int n2 = L; /* number of bits in v2, assumed nonzero */ 191 i = 0; 192 193 do { 194 const int bb = (v2 >> --n2) & 1; 195 split = 1 + (((range - 1) * proba[i >> 1]) >> 8); 196 i = b->tree[i + bb]; 197 198 if (bb) { 199 lowvalue += split; 200 range = range - split; 201 } else { 202 range = split; 203 } 204 205 shift = vp8_norm[range]; 206 range <<= shift; 207 count += shift; 208 209 if (count >= 0) { 210 int offset = shift - count; 211 212 if ((lowvalue << (offset - 1)) & 0x80000000) { 213 int x = w->pos - 1; 214 215 while (x >= 0 && w->buffer[x] == 0xff) { 216 w->buffer[x] = (unsigned char)0; 217 x--; 218 } 219 220 w->buffer[x] += 1; 221 } 222 223 validate_buffer(w->buffer + w->pos, 1, w->buffer_end, w->error); 224 225 w->buffer[w->pos++] = (lowvalue >> (24 - offset)); 226 lowvalue <<= offset; 227 shift = count; 228 lowvalue &= 0xffffff; 229 count -= 8; 230 } 231 232 lowvalue <<= shift; 233 } while (n2); 234 } 235 236 { 237 split = (range + 1) >> 1; 238 239 if (e & 1) { 240 lowvalue += split; 241 range = range - split; 242 } else { 243 range = split; 244 } 245 246 range <<= 1; 247 248 if ((lowvalue & 0x80000000)) { 249 int x = w->pos - 1; 250 251 while (x >= 0 && w->buffer[x] == 0xff) { 252 w->buffer[x] = (unsigned char)0; 253 x--; 254 } 255 256 w->buffer[x] += 1; 257 } 258 259 lowvalue <<= 1; 260 261 if (!++count) { 262 count = -8; 263 264 validate_buffer(w->buffer + w->pos, 1, w->buffer_end, w->error); 265 266 w->buffer[w->pos++] = (lowvalue >> 24); 267 lowvalue &= 0xffffff; 268 } 269 } 270 } 271 272 ++p; 273 } 274 275 w->count = count; 276 w->lowvalue = lowvalue; 277 w->range = range; 278 } 279 280 static void write_partition_size(unsigned char *cx_data, int size) { 281 signed char csize; 282 283 csize = size & 0xff; 284 *cx_data = csize; 285 csize = (size >> 8) & 0xff; 286 *(cx_data + 1) = csize; 287 csize = (size >> 16) & 0xff; 288 *(cx_data + 2) = csize; 289 } 290 291 static void pack_tokens_into_partitions(VP8_COMP *cpi, unsigned char *cx_data, 292 unsigned char *cx_data_end, 293 int num_part) { 294 int i; 295 unsigned char *ptr = cx_data; 296 unsigned char *ptr_end = cx_data_end; 297 vp8_writer *w; 298 299 for (i = 0; i < num_part; ++i) { 300 int mb_row; 301 302 w = cpi->bc + i + 1; 303 304 vp8_start_encode(w, ptr, ptr_end); 305 306 for (mb_row = i; mb_row < cpi->common.mb_rows; mb_row += num_part) { 307 const TOKENEXTRA *p = cpi->tplist[mb_row].start; 308 const TOKENEXTRA *stop = cpi->tplist[mb_row].stop; 309 int tokens = (int)(stop - p); 310 311 vp8_pack_tokens(w, p, tokens); 312 } 313 314 vp8_stop_encode(w); 315 ptr += w->pos; 316 } 317 } 318 319 #if CONFIG_MULTITHREAD 320 static void pack_mb_row_tokens(VP8_COMP *cpi, vp8_writer *w) { 321 int mb_row; 322 323 for (mb_row = 0; mb_row < cpi->common.mb_rows; ++mb_row) { 324 const TOKENEXTRA *p = cpi->tplist[mb_row].start; 325 const TOKENEXTRA *stop = cpi->tplist[mb_row].stop; 326 int tokens = (int)(stop - p); 327 328 vp8_pack_tokens(w, p, tokens); 329 } 330 } 331 #endif // CONFIG_MULTITHREAD 332 333 static void write_mv_ref(vp8_writer *w, MB_PREDICTION_MODE m, 334 const vp8_prob *p) { 335 assert(NEARESTMV <= m && m <= SPLITMV); 336 vp8_write_token(w, vp8_mv_ref_tree, p, 337 vp8_mv_ref_encoding_array + (m - NEARESTMV)); 338 } 339 340 static void write_sub_mv_ref(vp8_writer *w, B_PREDICTION_MODE m, 341 const vp8_prob *p) { 342 assert(LEFT4X4 <= m && m <= NEW4X4); 343 vp8_write_token(w, vp8_sub_mv_ref_tree, p, 344 vp8_sub_mv_ref_encoding_array + (m - LEFT4X4)); 345 } 346 347 static void write_mv(vp8_writer *w, const MV *mv, const int_mv *ref, 348 const MV_CONTEXT *mvc) { 349 MV e; 350 e.row = mv->row - ref->as_mv.row; 351 e.col = mv->col - ref->as_mv.col; 352 353 vp8_encode_motion_vector(w, &e, mvc); 354 } 355 356 static void write_mb_features(vp8_writer *w, const MB_MODE_INFO *mi, 357 const MACROBLOCKD *x) { 358 /* Encode the MB segment id. */ 359 if (x->segmentation_enabled && x->update_mb_segmentation_map) { 360 switch (mi->segment_id) { 361 case 0: 362 vp8_write(w, 0, x->mb_segment_tree_probs[0]); 363 vp8_write(w, 0, x->mb_segment_tree_probs[1]); 364 break; 365 case 1: 366 vp8_write(w, 0, x->mb_segment_tree_probs[0]); 367 vp8_write(w, 1, x->mb_segment_tree_probs[1]); 368 break; 369 case 2: 370 vp8_write(w, 1, x->mb_segment_tree_probs[0]); 371 vp8_write(w, 0, x->mb_segment_tree_probs[2]); 372 break; 373 case 3: 374 vp8_write(w, 1, x->mb_segment_tree_probs[0]); 375 vp8_write(w, 1, x->mb_segment_tree_probs[2]); 376 break; 377 378 /* TRAP.. This should not happen */ 379 default: 380 vp8_write(w, 0, x->mb_segment_tree_probs[0]); 381 vp8_write(w, 0, x->mb_segment_tree_probs[1]); 382 break; 383 } 384 } 385 } 386 void vp8_convert_rfct_to_prob(VP8_COMP *const cpi) { 387 const int *const rfct = cpi->mb.count_mb_ref_frame_usage; 388 const int rf_intra = rfct[INTRA_FRAME]; 389 const int rf_inter = 390 rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]; 391 392 /* Calculate the probabilities used to code the ref frame based on usage */ 393 if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter))) { 394 cpi->prob_intra_coded = 1; 395 } 396 397 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128; 398 399 if (!cpi->prob_last_coded) cpi->prob_last_coded = 1; 400 401 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) 402 ? (rfct[GOLDEN_FRAME] * 255) / 403 (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) 404 : 128; 405 406 if (!cpi->prob_gf_coded) cpi->prob_gf_coded = 1; 407 } 408 409 static void pack_inter_mode_mvs(VP8_COMP *const cpi) { 410 VP8_COMMON *const pc = &cpi->common; 411 vp8_writer *const w = cpi->bc; 412 const MV_CONTEXT *mvc = pc->fc.mvc; 413 414 MODE_INFO *m = pc->mi; 415 const int mis = pc->mode_info_stride; 416 int mb_row = -1; 417 418 int prob_skip_false = 0; 419 420 cpi->mb.partition_info = cpi->mb.pi; 421 422 vp8_convert_rfct_to_prob(cpi); 423 424 if (pc->mb_no_coeff_skip) { 425 int total_mbs = pc->mb_rows * pc->mb_cols; 426 427 prob_skip_false = (total_mbs - cpi->mb.skip_true_count) * 256 / total_mbs; 428 429 if (prob_skip_false <= 1) prob_skip_false = 1; 430 431 if (prob_skip_false > 255) prob_skip_false = 255; 432 433 cpi->prob_skip_false = prob_skip_false; 434 vp8_write_literal(w, prob_skip_false, 8); 435 } 436 437 vp8_write_literal(w, cpi->prob_intra_coded, 8); 438 vp8_write_literal(w, cpi->prob_last_coded, 8); 439 vp8_write_literal(w, cpi->prob_gf_coded, 8); 440 441 update_mbintra_mode_probs(cpi); 442 443 vp8_write_mvprobs(cpi); 444 445 while (++mb_row < pc->mb_rows) { 446 int mb_col = -1; 447 448 while (++mb_col < pc->mb_cols) { 449 const MB_MODE_INFO *const mi = &m->mbmi; 450 const MV_REFERENCE_FRAME rf = mi->ref_frame; 451 const MB_PREDICTION_MODE mode = mi->mode; 452 453 MACROBLOCKD *xd = &cpi->mb.e_mbd; 454 455 /* Distance of Mb to the various image edges. 456 * These specified to 8th pel as they are always compared to MV 457 * values that are in 1/8th pel units 458 */ 459 xd->mb_to_left_edge = -((mb_col * 16) << 3); 460 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3; 461 xd->mb_to_top_edge = -((mb_row * 16) << 3); 462 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3; 463 464 if (cpi->mb.e_mbd.update_mb_segmentation_map) { 465 write_mb_features(w, mi, &cpi->mb.e_mbd); 466 } 467 468 if (pc->mb_no_coeff_skip) { 469 vp8_encode_bool(w, m->mbmi.mb_skip_coeff, prob_skip_false); 470 } 471 472 if (rf == INTRA_FRAME) { 473 vp8_write(w, 0, cpi->prob_intra_coded); 474 write_ymode(w, mode, pc->fc.ymode_prob); 475 476 if (mode == B_PRED) { 477 int j = 0; 478 479 do { 480 write_bmode(w, m->bmi[j].as_mode, pc->fc.bmode_prob); 481 } while (++j < 16); 482 } 483 484 write_uv_mode(w, mi->uv_mode, pc->fc.uv_mode_prob); 485 } else { /* inter coded */ 486 int_mv best_mv; 487 vp8_prob mv_ref_p[VP8_MVREFS - 1]; 488 489 vp8_write(w, 1, cpi->prob_intra_coded); 490 491 if (rf == LAST_FRAME) 492 vp8_write(w, 0, cpi->prob_last_coded); 493 else { 494 vp8_write(w, 1, cpi->prob_last_coded); 495 vp8_write(w, (rf == GOLDEN_FRAME) ? 0 : 1, cpi->prob_gf_coded); 496 } 497 498 { 499 int_mv n1, n2; 500 int ct[4]; 501 502 vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, 503 cpi->common.ref_frame_sign_bias); 504 vp8_clamp_mv2(&best_mv, xd); 505 506 vp8_mv_ref_probs(mv_ref_p, ct); 507 } 508 509 write_mv_ref(w, mode, mv_ref_p); 510 511 switch (mode) /* new, split require MVs */ 512 { 513 case NEWMV: write_mv(w, &mi->mv.as_mv, &best_mv, mvc); break; 514 515 case SPLITMV: { 516 int j = 0; 517 518 #ifdef MODE_STATS 519 ++count_mb_seg[mi->partitioning]; 520 #endif 521 522 write_split(w, mi->partitioning); 523 524 do { 525 B_PREDICTION_MODE blockmode; 526 int_mv blockmv; 527 const int *const L = vp8_mbsplits[mi->partitioning]; 528 int k = -1; /* first block in subset j */ 529 int mv_contz; 530 int_mv leftmv, abovemv; 531 532 blockmode = cpi->mb.partition_info->bmi[j].mode; 533 blockmv = cpi->mb.partition_info->bmi[j].mv; 534 while (j != L[++k]) { 535 assert(k < 16); 536 } 537 leftmv.as_int = left_block_mv(m, k); 538 abovemv.as_int = above_block_mv(m, k, mis); 539 mv_contz = vp8_mv_cont(&leftmv, &abovemv); 540 541 write_sub_mv_ref(w, blockmode, vp8_sub_mv_ref_prob2[mv_contz]); 542 543 if (blockmode == NEW4X4) { 544 write_mv(w, &blockmv.as_mv, &best_mv, (const MV_CONTEXT *)mvc); 545 } 546 } while (++j < cpi->mb.partition_info->count); 547 break; 548 } 549 default: break; 550 } 551 } 552 553 ++m; 554 cpi->mb.partition_info++; 555 } 556 557 ++m; /* skip L prediction border */ 558 cpi->mb.partition_info++; 559 } 560 } 561 562 static void write_kfmodes(VP8_COMP *cpi) { 563 vp8_writer *const bc = cpi->bc; 564 const VP8_COMMON *const c = &cpi->common; 565 /* const */ 566 MODE_INFO *m = c->mi; 567 568 int mb_row = -1; 569 int prob_skip_false = 0; 570 571 if (c->mb_no_coeff_skip) { 572 int total_mbs = c->mb_rows * c->mb_cols; 573 574 prob_skip_false = (total_mbs - cpi->mb.skip_true_count) * 256 / total_mbs; 575 576 if (prob_skip_false <= 1) prob_skip_false = 1; 577 578 if (prob_skip_false >= 255) prob_skip_false = 255; 579 580 cpi->prob_skip_false = prob_skip_false; 581 vp8_write_literal(bc, prob_skip_false, 8); 582 } 583 584 while (++mb_row < c->mb_rows) { 585 int mb_col = -1; 586 587 while (++mb_col < c->mb_cols) { 588 const int ym = m->mbmi.mode; 589 590 if (cpi->mb.e_mbd.update_mb_segmentation_map) { 591 write_mb_features(bc, &m->mbmi, &cpi->mb.e_mbd); 592 } 593 594 if (c->mb_no_coeff_skip) { 595 vp8_encode_bool(bc, m->mbmi.mb_skip_coeff, prob_skip_false); 596 } 597 598 kfwrite_ymode(bc, ym, vp8_kf_ymode_prob); 599 600 if (ym == B_PRED) { 601 const int mis = c->mode_info_stride; 602 int i = 0; 603 604 do { 605 const B_PREDICTION_MODE A = above_block_mode(m, i, mis); 606 const B_PREDICTION_MODE L = left_block_mode(m, i); 607 const int bm = m->bmi[i].as_mode; 608 609 write_bmode(bc, bm, vp8_kf_bmode_prob[A][L]); 610 } while (++i < 16); 611 } 612 613 write_uv_mode(bc, (m++)->mbmi.uv_mode, vp8_kf_uv_mode_prob); 614 } 615 616 m++; /* skip L prediction border */ 617 } 618 } 619 620 #if 0 621 /* This function is used for debugging probability trees. */ 622 static void print_prob_tree(vp8_prob 623 coef_probs[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES]) 624 { 625 /* print coef probability tree */ 626 int i,j,k,l; 627 FILE* f = fopen("enc_tree_probs.txt", "a"); 628 fprintf(f, "{\n"); 629 for (i = 0; i < BLOCK_TYPES; ++i) 630 { 631 fprintf(f, " {\n"); 632 for (j = 0; j < COEF_BANDS; ++j) 633 { 634 fprintf(f, " {\n"); 635 for (k = 0; k < PREV_COEF_CONTEXTS; ++k) 636 { 637 fprintf(f, " {"); 638 for (l = 0; l < ENTROPY_NODES; ++l) 639 { 640 fprintf(f, "%3u, ", 641 (unsigned int)(coef_probs [i][j][k][l])); 642 } 643 fprintf(f, " }\n"); 644 } 645 fprintf(f, " }\n"); 646 } 647 fprintf(f, " }\n"); 648 } 649 fprintf(f, "}\n"); 650 fclose(f); 651 } 652 #endif 653 654 static void sum_probs_over_prev_coef_context( 655 const unsigned int probs[PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS], 656 unsigned int *out) { 657 int i, j; 658 for (i = 0; i < MAX_ENTROPY_TOKENS; ++i) { 659 for (j = 0; j < PREV_COEF_CONTEXTS; ++j) { 660 const unsigned int tmp = out[i]; 661 out[i] += probs[j][i]; 662 /* check for wrap */ 663 if (out[i] < tmp) out[i] = UINT_MAX; 664 } 665 } 666 } 667 668 static int prob_update_savings(const unsigned int *ct, const vp8_prob oldp, 669 const vp8_prob newp, const vp8_prob upd) { 670 const int old_b = vp8_cost_branch(ct, oldp); 671 const int new_b = vp8_cost_branch(ct, newp); 672 const int update_b = 8 + ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8); 673 674 return old_b - new_b - update_b; 675 } 676 677 static int independent_coef_context_savings(VP8_COMP *cpi) { 678 MACROBLOCK *const x = &cpi->mb; 679 int savings = 0; 680 int i = 0; 681 do { 682 int j = 0; 683 do { 684 int k = 0; 685 unsigned int prev_coef_count_sum[MAX_ENTROPY_TOKENS] = { 0 }; 686 int prev_coef_savings[MAX_ENTROPY_TOKENS] = { 0 }; 687 const unsigned int(*probs)[MAX_ENTROPY_TOKENS]; 688 /* Calculate new probabilities given the constraint that 689 * they must be equal over the prev coef contexts 690 */ 691 692 probs = (const unsigned int(*)[MAX_ENTROPY_TOKENS])x->coef_counts[i][j]; 693 694 /* Reset to default probabilities at key frames */ 695 if (cpi->common.frame_type == KEY_FRAME) { 696 probs = default_coef_counts[i][j]; 697 } 698 699 sum_probs_over_prev_coef_context(probs, prev_coef_count_sum); 700 701 do { 702 /* at every context */ 703 704 /* calc probs and branch cts for this frame only */ 705 int t = 0; /* token/prob index */ 706 707 vp8_tree_probs_from_distribution( 708 MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree, 709 cpi->frame_coef_probs[i][j][k], cpi->frame_branch_ct[i][j][k], 710 prev_coef_count_sum, 256, 1); 711 712 do { 713 const unsigned int *ct = cpi->frame_branch_ct[i][j][k][t]; 714 const vp8_prob newp = cpi->frame_coef_probs[i][j][k][t]; 715 const vp8_prob oldp = cpi->common.fc.coef_probs[i][j][k][t]; 716 const vp8_prob upd = vp8_coef_update_probs[i][j][k][t]; 717 const int s = prob_update_savings(ct, oldp, newp, upd); 718 719 if (cpi->common.frame_type != KEY_FRAME || 720 (cpi->common.frame_type == KEY_FRAME && newp != oldp)) { 721 prev_coef_savings[t] += s; 722 } 723 } while (++t < ENTROPY_NODES); 724 } while (++k < PREV_COEF_CONTEXTS); 725 k = 0; 726 do { 727 /* We only update probabilities if we can save bits, except 728 * for key frames where we have to update all probabilities 729 * to get the equal probabilities across the prev coef 730 * contexts. 731 */ 732 if (prev_coef_savings[k] > 0 || cpi->common.frame_type == KEY_FRAME) { 733 savings += prev_coef_savings[k]; 734 } 735 } while (++k < ENTROPY_NODES); 736 } while (++j < COEF_BANDS); 737 } while (++i < BLOCK_TYPES); 738 return savings; 739 } 740 741 static int default_coef_context_savings(VP8_COMP *cpi) { 742 MACROBLOCK *const x = &cpi->mb; 743 int savings = 0; 744 int i = 0; 745 do { 746 int j = 0; 747 do { 748 int k = 0; 749 do { 750 /* at every context */ 751 752 /* calc probs and branch cts for this frame only */ 753 int t = 0; /* token/prob index */ 754 755 vp8_tree_probs_from_distribution( 756 MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree, 757 cpi->frame_coef_probs[i][j][k], cpi->frame_branch_ct[i][j][k], 758 x->coef_counts[i][j][k], 256, 1); 759 760 do { 761 const unsigned int *ct = cpi->frame_branch_ct[i][j][k][t]; 762 const vp8_prob newp = cpi->frame_coef_probs[i][j][k][t]; 763 const vp8_prob oldp = cpi->common.fc.coef_probs[i][j][k][t]; 764 const vp8_prob upd = vp8_coef_update_probs[i][j][k][t]; 765 const int s = prob_update_savings(ct, oldp, newp, upd); 766 767 if (s > 0) { 768 savings += s; 769 } 770 } while (++t < ENTROPY_NODES); 771 } while (++k < PREV_COEF_CONTEXTS); 772 } while (++j < COEF_BANDS); 773 } while (++i < BLOCK_TYPES); 774 return savings; 775 } 776 777 void vp8_calc_ref_frame_costs(int *ref_frame_cost, int prob_intra, 778 int prob_last, int prob_garf) { 779 assert(prob_intra >= 0); 780 assert(prob_intra <= 255); 781 assert(prob_last >= 0); 782 assert(prob_last <= 255); 783 assert(prob_garf >= 0); 784 assert(prob_garf <= 255); 785 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(prob_intra); 786 ref_frame_cost[LAST_FRAME] = 787 vp8_cost_one(prob_intra) + vp8_cost_zero(prob_last); 788 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(prob_intra) + 789 vp8_cost_one(prob_last) + 790 vp8_cost_zero(prob_garf); 791 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(prob_intra) + 792 vp8_cost_one(prob_last) + 793 vp8_cost_one(prob_garf); 794 } 795 796 int vp8_estimate_entropy_savings(VP8_COMP *cpi) { 797 int savings = 0; 798 799 const int *const rfct = cpi->mb.count_mb_ref_frame_usage; 800 const int rf_intra = rfct[INTRA_FRAME]; 801 const int rf_inter = 802 rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]; 803 int new_intra, new_last, new_garf, oldtotal, newtotal; 804 int ref_frame_cost[MAX_REF_FRAMES]; 805 806 vpx_clear_system_state(); 807 808 if (cpi->common.frame_type != KEY_FRAME) { 809 if (!(new_intra = rf_intra * 255 / (rf_intra + rf_inter))) new_intra = 1; 810 811 new_last = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128; 812 813 new_garf = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) 814 ? (rfct[GOLDEN_FRAME] * 255) / 815 (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) 816 : 128; 817 818 vp8_calc_ref_frame_costs(ref_frame_cost, new_intra, new_last, new_garf); 819 820 newtotal = rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] + 821 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] + 822 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] + 823 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME]; 824 825 /* old costs */ 826 vp8_calc_ref_frame_costs(ref_frame_cost, cpi->prob_intra_coded, 827 cpi->prob_last_coded, cpi->prob_gf_coded); 828 829 oldtotal = rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] + 830 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] + 831 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] + 832 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME]; 833 834 savings += (oldtotal - newtotal) / 256; 835 } 836 837 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) { 838 savings += independent_coef_context_savings(cpi); 839 } else { 840 savings += default_coef_context_savings(cpi); 841 } 842 843 return savings; 844 } 845 846 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 847 int vp8_update_coef_context(VP8_COMP *cpi) { 848 int savings = 0; 849 850 if (cpi->common.frame_type == KEY_FRAME) { 851 /* Reset to default counts/probabilities at key frames */ 852 vp8_copy(cpi->mb.coef_counts, default_coef_counts); 853 } 854 855 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) 856 savings += independent_coef_context_savings(cpi); 857 else 858 savings += default_coef_context_savings(cpi); 859 860 return savings; 861 } 862 #endif 863 864 void vp8_update_coef_probs(VP8_COMP *cpi) { 865 int i = 0; 866 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) 867 vp8_writer *const w = cpi->bc; 868 #endif 869 int savings = 0; 870 871 vpx_clear_system_state(); 872 873 do { 874 int j = 0; 875 876 do { 877 int k = 0; 878 int prev_coef_savings[ENTROPY_NODES] = { 0 }; 879 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) { 880 for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { 881 int t; /* token/prob index */ 882 for (t = 0; t < ENTROPY_NODES; ++t) { 883 const unsigned int *ct = cpi->frame_branch_ct[i][j][k][t]; 884 const vp8_prob newp = cpi->frame_coef_probs[i][j][k][t]; 885 const vp8_prob oldp = cpi->common.fc.coef_probs[i][j][k][t]; 886 const vp8_prob upd = vp8_coef_update_probs[i][j][k][t]; 887 888 prev_coef_savings[t] += prob_update_savings(ct, oldp, newp, upd); 889 } 890 } 891 k = 0; 892 } 893 do { 894 /* note: use result from vp8_estimate_entropy_savings, so no 895 * need to call vp8_tree_probs_from_distribution here. 896 */ 897 898 /* at every context */ 899 900 /* calc probs and branch cts for this frame only */ 901 int t = 0; /* token/prob index */ 902 903 do { 904 const vp8_prob newp = cpi->frame_coef_probs[i][j][k][t]; 905 906 vp8_prob *Pold = cpi->common.fc.coef_probs[i][j][k] + t; 907 const vp8_prob upd = vp8_coef_update_probs[i][j][k][t]; 908 909 int s = prev_coef_savings[t]; 910 int u = 0; 911 912 if (!(cpi->oxcf.error_resilient_mode & 913 VPX_ERROR_RESILIENT_PARTITIONS)) { 914 s = prob_update_savings(cpi->frame_branch_ct[i][j][k][t], *Pold, 915 newp, upd); 916 } 917 918 if (s > 0) u = 1; 919 920 /* Force updates on key frames if the new is different, 921 * so that we can be sure we end up with equal probabilities 922 * over the prev coef contexts. 923 */ 924 if ((cpi->oxcf.error_resilient_mode & 925 VPX_ERROR_RESILIENT_PARTITIONS) && 926 cpi->common.frame_type == KEY_FRAME && newp != *Pold) { 927 u = 1; 928 } 929 930 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 931 cpi->update_probs[i][j][k][t] = u; 932 #else 933 vp8_write(w, u, upd); 934 #endif 935 936 if (u) { 937 /* send/use new probability */ 938 939 *Pold = newp; 940 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) 941 vp8_write_literal(w, newp, 8); 942 #endif 943 944 savings += s; 945 } 946 947 } while (++t < ENTROPY_NODES); 948 949 } while (++k < PREV_COEF_CONTEXTS); 950 } while (++j < COEF_BANDS); 951 } while (++i < BLOCK_TYPES); 952 } 953 954 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 955 static void pack_coef_probs(VP8_COMP *cpi) { 956 int i = 0; 957 vp8_writer *const w = cpi->bc; 958 959 do { 960 int j = 0; 961 962 do { 963 int k = 0; 964 965 do { 966 int t = 0; /* token/prob index */ 967 968 do { 969 const vp8_prob newp = cpi->common.fc.coef_probs[i][j][k][t]; 970 const vp8_prob upd = vp8_coef_update_probs[i][j][k][t]; 971 972 const char u = cpi->update_probs[i][j][k][t]; 973 974 vp8_write(w, u, upd); 975 976 if (u) { 977 /* send/use new probability */ 978 vp8_write_literal(w, newp, 8); 979 } 980 } while (++t < ENTROPY_NODES); 981 } while (++k < PREV_COEF_CONTEXTS); 982 } while (++j < COEF_BANDS); 983 } while (++i < BLOCK_TYPES); 984 } 985 #endif 986 987 #ifdef PACKET_TESTING 988 FILE *vpxlogc = 0; 989 #endif 990 991 static void put_delta_q(vp8_writer *bc, int delta_q) { 992 if (delta_q != 0) { 993 vp8_write_bit(bc, 1); 994 vp8_write_literal(bc, abs(delta_q), 4); 995 996 if (delta_q < 0) 997 vp8_write_bit(bc, 1); 998 else 999 vp8_write_bit(bc, 0); 1000 } else 1001 vp8_write_bit(bc, 0); 1002 } 1003 1004 void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, 1005 unsigned char *dest_end, size_t *size) { 1006 int i, j; 1007 VP8_HEADER oh; 1008 VP8_COMMON *const pc = &cpi->common; 1009 vp8_writer *const bc = cpi->bc; 1010 MACROBLOCKD *const xd = &cpi->mb.e_mbd; 1011 int extra_bytes_packed = 0; 1012 1013 unsigned char *cx_data = dest; 1014 unsigned char *cx_data_end = dest_end; 1015 const int *mb_feature_data_bits; 1016 1017 oh.show_frame = (int)pc->show_frame; 1018 oh.type = (int)pc->frame_type; 1019 oh.version = pc->version; 1020 oh.first_partition_length_in_bytes = 0; 1021 1022 mb_feature_data_bits = vp8_mb_feature_data_bits; 1023 1024 bc[0].error = &pc->error; 1025 1026 validate_buffer(cx_data, 3, cx_data_end, &cpi->common.error); 1027 cx_data += 3; 1028 1029 #if defined(SECTIONBITS_OUTPUT) 1030 Sectionbits[active_section = 1] += sizeof(VP8_HEADER) * 8 * 256; 1031 #endif 1032 1033 /* every keyframe send startcode, width, height, scale factor, clamp 1034 * and color type 1035 */ 1036 if (oh.type == KEY_FRAME) { 1037 int v; 1038 1039 validate_buffer(cx_data, 7, cx_data_end, &cpi->common.error); 1040 1041 /* Start / synch code */ 1042 cx_data[0] = 0x9D; 1043 cx_data[1] = 0x01; 1044 cx_data[2] = 0x2a; 1045 1046 v = (pc->horiz_scale << 14) | pc->Width; 1047 cx_data[3] = v; 1048 cx_data[4] = v >> 8; 1049 1050 v = (pc->vert_scale << 14) | pc->Height; 1051 cx_data[5] = v; 1052 cx_data[6] = v >> 8; 1053 1054 extra_bytes_packed = 7; 1055 cx_data += extra_bytes_packed; 1056 1057 vp8_start_encode(bc, cx_data, cx_data_end); 1058 1059 /* signal clr type */ 1060 vp8_write_bit(bc, 0); 1061 vp8_write_bit(bc, pc->clamp_type); 1062 1063 } else { 1064 vp8_start_encode(bc, cx_data, cx_data_end); 1065 } 1066 1067 /* Signal whether or not Segmentation is enabled */ 1068 vp8_write_bit(bc, xd->segmentation_enabled); 1069 1070 /* Indicate which features are enabled */ 1071 if (xd->segmentation_enabled) { 1072 /* Signal whether or not the segmentation map is being updated. */ 1073 vp8_write_bit(bc, xd->update_mb_segmentation_map); 1074 vp8_write_bit(bc, xd->update_mb_segmentation_data); 1075 1076 if (xd->update_mb_segmentation_data) { 1077 signed char Data; 1078 1079 vp8_write_bit(bc, xd->mb_segement_abs_delta); 1080 1081 /* For each segmentation feature (Quant and loop filter level) */ 1082 for (i = 0; i < MB_LVL_MAX; ++i) { 1083 /* For each of the segments */ 1084 for (j = 0; j < MAX_MB_SEGMENTS; ++j) { 1085 Data = xd->segment_feature_data[i][j]; 1086 1087 /* Frame level data */ 1088 if (Data) { 1089 vp8_write_bit(bc, 1); 1090 1091 if (Data < 0) { 1092 Data = -Data; 1093 vp8_write_literal(bc, Data, mb_feature_data_bits[i]); 1094 vp8_write_bit(bc, 1); 1095 } else { 1096 vp8_write_literal(bc, Data, mb_feature_data_bits[i]); 1097 vp8_write_bit(bc, 0); 1098 } 1099 } else 1100 vp8_write_bit(bc, 0); 1101 } 1102 } 1103 } 1104 1105 if (xd->update_mb_segmentation_map) { 1106 /* Write the probs used to decode the segment id for each mb */ 1107 for (i = 0; i < MB_FEATURE_TREE_PROBS; ++i) { 1108 int Data = xd->mb_segment_tree_probs[i]; 1109 1110 if (Data != 255) { 1111 vp8_write_bit(bc, 1); 1112 vp8_write_literal(bc, Data, 8); 1113 } else 1114 vp8_write_bit(bc, 0); 1115 } 1116 } 1117 } 1118 1119 vp8_write_bit(bc, pc->filter_type); 1120 vp8_write_literal(bc, pc->filter_level, 6); 1121 vp8_write_literal(bc, pc->sharpness_level, 3); 1122 1123 /* Write out loop filter deltas applied at the MB level based on mode 1124 * or ref frame (if they are enabled). 1125 */ 1126 vp8_write_bit(bc, xd->mode_ref_lf_delta_enabled); 1127 1128 if (xd->mode_ref_lf_delta_enabled) { 1129 /* Do the deltas need to be updated */ 1130 int send_update = 1131 xd->mode_ref_lf_delta_update || cpi->oxcf.error_resilient_mode; 1132 1133 vp8_write_bit(bc, send_update); 1134 if (send_update) { 1135 int Data; 1136 1137 /* Send update */ 1138 for (i = 0; i < MAX_REF_LF_DELTAS; ++i) { 1139 Data = xd->ref_lf_deltas[i]; 1140 1141 /* Frame level data */ 1142 if (xd->ref_lf_deltas[i] != xd->last_ref_lf_deltas[i] || 1143 cpi->oxcf.error_resilient_mode) { 1144 xd->last_ref_lf_deltas[i] = xd->ref_lf_deltas[i]; 1145 vp8_write_bit(bc, 1); 1146 1147 if (Data > 0) { 1148 vp8_write_literal(bc, (Data & 0x3F), 6); 1149 vp8_write_bit(bc, 0); /* sign */ 1150 } else { 1151 Data = -Data; 1152 vp8_write_literal(bc, (Data & 0x3F), 6); 1153 vp8_write_bit(bc, 1); /* sign */ 1154 } 1155 } else 1156 vp8_write_bit(bc, 0); 1157 } 1158 1159 /* Send update */ 1160 for (i = 0; i < MAX_MODE_LF_DELTAS; ++i) { 1161 Data = xd->mode_lf_deltas[i]; 1162 1163 if (xd->mode_lf_deltas[i] != xd->last_mode_lf_deltas[i] || 1164 cpi->oxcf.error_resilient_mode) { 1165 xd->last_mode_lf_deltas[i] = xd->mode_lf_deltas[i]; 1166 vp8_write_bit(bc, 1); 1167 1168 if (Data > 0) { 1169 vp8_write_literal(bc, (Data & 0x3F), 6); 1170 vp8_write_bit(bc, 0); /* sign */ 1171 } else { 1172 Data = -Data; 1173 vp8_write_literal(bc, (Data & 0x3F), 6); 1174 vp8_write_bit(bc, 1); /* sign */ 1175 } 1176 } else 1177 vp8_write_bit(bc, 0); 1178 } 1179 } 1180 } 1181 1182 /* signal here is multi token partition is enabled */ 1183 vp8_write_literal(bc, pc->multi_token_partition, 2); 1184 1185 /* Frame Qbaseline quantizer index */ 1186 vp8_write_literal(bc, pc->base_qindex, 7); 1187 1188 /* Transmit Dc, Second order and Uv quantizer delta information */ 1189 put_delta_q(bc, pc->y1dc_delta_q); 1190 put_delta_q(bc, pc->y2dc_delta_q); 1191 put_delta_q(bc, pc->y2ac_delta_q); 1192 put_delta_q(bc, pc->uvdc_delta_q); 1193 put_delta_q(bc, pc->uvac_delta_q); 1194 1195 /* When there is a key frame all reference buffers are updated using 1196 * the new key frame 1197 */ 1198 if (pc->frame_type != KEY_FRAME) { 1199 /* Should the GF or ARF be updated using the transmitted frame 1200 * or buffer 1201 */ 1202 vp8_write_bit(bc, pc->refresh_golden_frame); 1203 vp8_write_bit(bc, pc->refresh_alt_ref_frame); 1204 1205 /* If not being updated from current frame should either GF or ARF 1206 * be updated from another buffer 1207 */ 1208 if (!pc->refresh_golden_frame) 1209 vp8_write_literal(bc, pc->copy_buffer_to_gf, 2); 1210 1211 if (!pc->refresh_alt_ref_frame) 1212 vp8_write_literal(bc, pc->copy_buffer_to_arf, 2); 1213 1214 /* Indicate reference frame sign bias for Golden and ARF frames 1215 * (always 0 for last frame buffer) 1216 */ 1217 vp8_write_bit(bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]); 1218 vp8_write_bit(bc, pc->ref_frame_sign_bias[ALTREF_FRAME]); 1219 } 1220 1221 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) 1222 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) { 1223 if (pc->frame_type == KEY_FRAME) { 1224 pc->refresh_entropy_probs = 1; 1225 } else { 1226 pc->refresh_entropy_probs = 0; 1227 } 1228 } 1229 #endif 1230 1231 vp8_write_bit(bc, pc->refresh_entropy_probs); 1232 1233 if (pc->frame_type != KEY_FRAME) vp8_write_bit(bc, pc->refresh_last_frame); 1234 1235 vpx_clear_system_state(); 1236 1237 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 1238 pack_coef_probs(cpi); 1239 #else 1240 if (pc->refresh_entropy_probs == 0) { 1241 /* save a copy for later refresh */ 1242 memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc)); 1243 } 1244 1245 vp8_update_coef_probs(cpi); 1246 #endif 1247 1248 /* Write out the mb_no_coeff_skip flag */ 1249 vp8_write_bit(bc, pc->mb_no_coeff_skip); 1250 1251 if (pc->frame_type == KEY_FRAME) { 1252 write_kfmodes(cpi); 1253 } else { 1254 pack_inter_mode_mvs(cpi); 1255 } 1256 1257 vp8_stop_encode(bc); 1258 1259 cx_data += bc->pos; 1260 1261 oh.first_partition_length_in_bytes = cpi->bc->pos; 1262 1263 /* update frame tag */ 1264 { 1265 int v = (oh.first_partition_length_in_bytes << 5) | (oh.show_frame << 4) | 1266 (oh.version << 1) | oh.type; 1267 1268 dest[0] = v; 1269 dest[1] = v >> 8; 1270 dest[2] = v >> 16; 1271 } 1272 1273 *size = VP8_HEADER_SIZE + extra_bytes_packed + cpi->bc->pos; 1274 1275 cpi->partition_sz[0] = (unsigned int)*size; 1276 1277 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 1278 { 1279 const int num_part = (1 << pc->multi_token_partition); 1280 unsigned char *dp = cpi->partition_d[0] + cpi->partition_sz[0]; 1281 1282 if (num_part > 1) { 1283 /* write token part sizes (all but last) if more than 1 */ 1284 validate_buffer(dp, 3 * (num_part - 1), cpi->partition_d_end[0], 1285 &pc->error); 1286 1287 cpi->partition_sz[0] += 3 * (num_part - 1); 1288 1289 for (i = 1; i < num_part; ++i) { 1290 write_partition_size(dp, cpi->partition_sz[i]); 1291 dp += 3; 1292 } 1293 } 1294 1295 if (!cpi->output_partition) { 1296 /* concatenate partition buffers */ 1297 for (i = 0; i < num_part; ++i) { 1298 memmove(dp, cpi->partition_d[i + 1], cpi->partition_sz[i + 1]); 1299 cpi->partition_d[i + 1] = dp; 1300 dp += cpi->partition_sz[i + 1]; 1301 } 1302 } 1303 1304 /* update total size */ 1305 *size = 0; 1306 for (i = 0; i < num_part + 1; ++i) { 1307 *size += cpi->partition_sz[i]; 1308 } 1309 } 1310 #else 1311 if (pc->multi_token_partition != ONE_PARTITION) { 1312 int num_part = 1 << pc->multi_token_partition; 1313 1314 /* partition size table at the end of first partition */ 1315 cpi->partition_sz[0] += 3 * (num_part - 1); 1316 *size += 3 * (num_part - 1); 1317 1318 validate_buffer(cx_data, 3 * (num_part - 1), cx_data_end, &pc->error); 1319 1320 for (i = 1; i < num_part + 1; ++i) { 1321 cpi->bc[i].error = &pc->error; 1322 } 1323 1324 pack_tokens_into_partitions(cpi, cx_data + 3 * (num_part - 1), cx_data_end, 1325 num_part); 1326 1327 for (i = 1; i < num_part; ++i) { 1328 cpi->partition_sz[i] = cpi->bc[i].pos; 1329 write_partition_size(cx_data, cpi->partition_sz[i]); 1330 cx_data += 3; 1331 *size += cpi->partition_sz[i]; /* add to total */ 1332 } 1333 1334 /* add last partition to total size */ 1335 cpi->partition_sz[i] = cpi->bc[i].pos; 1336 *size += cpi->partition_sz[i]; 1337 } else { 1338 bc[1].error = &pc->error; 1339 1340 vp8_start_encode(&cpi->bc[1], cx_data, cx_data_end); 1341 1342 #if CONFIG_MULTITHREAD 1343 if (vpx_atomic_load_acquire(&cpi->b_multi_threaded)) { 1344 pack_mb_row_tokens(cpi, &cpi->bc[1]); 1345 } else { 1346 vp8_pack_tokens(&cpi->bc[1], cpi->tok, cpi->tok_count); 1347 } 1348 #else 1349 vp8_pack_tokens(&cpi->bc[1], cpi->tok, cpi->tok_count); 1350 #endif // CONFIG_MULTITHREAD 1351 1352 vp8_stop_encode(&cpi->bc[1]); 1353 1354 *size += cpi->bc[1].pos; 1355 cpi->partition_sz[1] = cpi->bc[1].pos; 1356 } 1357 #endif 1358 } 1359
