Revision ccba4f4c libavcodec/vp8.c
| libavcodec/vp8.c | ||
|---|---|---|
| 528 | 528 |
((s->mb_height - 1 - mb_y) << 6) + MARGIN); |
| 529 | 529 |
} |
| 530 | 530 |
|
| 531 |
static av_always_inline |
|
| 532 |
void find_near_mvs(VP8Context *s, VP8Macroblock *mb, |
|
| 533 |
VP56mv near[2], VP56mv *best, uint8_t cnt[4]) |
|
| 534 |
{
|
|
| 535 |
VP8Macroblock *mb_edge[3] = { mb + 2 /* top */,
|
|
| 536 |
mb - 1 /* left */, |
|
| 537 |
mb + 1 /* top-left */ }; |
|
| 538 |
enum { EDGE_TOP, EDGE_LEFT, EDGE_TOPLEFT };
|
|
| 539 |
VP56mv near_mv[4] = {{ 0 }};
|
|
| 540 |
enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
|
|
| 541 |
int idx = CNT_ZERO; |
|
| 542 |
int best_idx = CNT_ZERO; |
|
| 543 |
int cur_sign_bias = s->sign_bias[mb->ref_frame]; |
|
| 544 |
int *sign_bias = s->sign_bias; |
|
| 545 |
|
|
| 546 |
/* Process MB on top, left and top-left */ |
|
| 547 |
#define MV_EDGE_CHECK(n)\ |
|
| 548 |
{\
|
|
| 549 |
VP8Macroblock *edge = mb_edge[n];\ |
|
| 550 |
int edge_ref = edge->ref_frame;\ |
|
| 551 |
if (edge_ref != VP56_FRAME_CURRENT) {\
|
|
| 552 |
uint32_t mv = AV_RN32A(&edge->mv);\ |
|
| 553 |
if (mv) {\
|
|
| 554 |
if (cur_sign_bias != sign_bias[edge_ref]) {\
|
|
| 555 |
/* SWAR negate of the values in mv. */\ |
|
| 556 |
mv = ~mv;\ |
|
| 557 |
mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\ |
|
| 558 |
}\ |
|
| 559 |
if (!n || mv != AV_RN32A(&near_mv[idx]))\ |
|
| 560 |
AV_WN32A(&near_mv[++idx], mv);\ |
|
| 561 |
cnt[idx] += 1 + (n != 2);\ |
|
| 562 |
} else\ |
|
| 563 |
cnt[CNT_ZERO] += 1 + (n != 2);\ |
|
| 564 |
}\ |
|
| 565 |
} |
|
| 566 |
MV_EDGE_CHECK(0) |
|
| 567 |
MV_EDGE_CHECK(1) |
|
| 568 |
MV_EDGE_CHECK(2) |
|
| 569 |
|
|
| 570 |
/* If we have three distinct MVs, merge first and last if they're the same */ |
|
| 571 |
if (cnt[CNT_SPLITMV] && AV_RN32A(&near_mv[1+EDGE_TOP]) == AV_RN32A(&near_mv[1+EDGE_TOPLEFT])) |
|
| 572 |
cnt[CNT_NEAREST] += 1; |
|
| 573 |
|
|
| 574 |
cnt[CNT_SPLITMV] = ((mb_edge[EDGE_LEFT]->mode == VP8_MVMODE_SPLIT) + |
|
| 575 |
(mb_edge[EDGE_TOP]->mode == VP8_MVMODE_SPLIT)) * 2 + |
|
| 576 |
(mb_edge[EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT); |
|
| 577 |
|
|
| 578 |
/* Swap near and nearest if necessary */ |
|
| 579 |
if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
|
|
| 580 |
FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]); |
|
| 581 |
FFSWAP( VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]); |
|
| 582 |
} |
|
| 583 |
|
|
| 584 |
/* Choose the best mv out of 0,0 and the nearest mv */ |
|
| 585 |
if (cnt[CNT_NEAREST] >= cnt[CNT_ZERO]) |
|
| 586 |
best_idx = CNT_NEAREST; |
|
| 587 |
|
|
| 588 |
mb->mv = near_mv[best_idx]; |
|
| 589 |
near[0] = near_mv[CNT_NEAREST]; |
|
| 590 |
near[1] = near_mv[CNT_NEAR]; |
|
| 591 |
} |
|
| 592 |
|
|
| 593 | 531 |
/** |
| 594 | 532 |
* Motion vector coding, 17.1. |
| 595 | 533 |
*/ |
| ... | ... | |
| 700 | 638 |
} |
| 701 | 639 |
|
| 702 | 640 |
static av_always_inline |
| 641 |
void decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y) |
|
| 642 |
{
|
|
| 643 |
VP8Macroblock *mb_edge[3] = { mb + 2 /* top */,
|
|
| 644 |
mb - 1 /* left */, |
|
| 645 |
mb + 1 /* top-left */ }; |
|
| 646 |
enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
|
|
| 647 |
enum { EDGE_TOP, EDGE_LEFT, EDGE_TOPLEFT };
|
|
| 648 |
int idx = CNT_ZERO; |
|
| 649 |
int cur_sign_bias = s->sign_bias[mb->ref_frame]; |
|
| 650 |
int *sign_bias = s->sign_bias; |
|
| 651 |
VP56mv near_mv[4]; |
|
| 652 |
uint8_t cnt[4] = { 0 };
|
|
| 653 |
VP56RangeCoder *c = &s->c; |
|
| 654 |
|
|
| 655 |
AV_ZERO32(&near_mv[0]); |
|
| 656 |
AV_ZERO32(&near_mv[1]); |
|
| 657 |
AV_ZERO32(&near_mv[2]); |
|
| 658 |
|
|
| 659 |
/* Process MB on top, left and top-left */ |
|
| 660 |
#define MV_EDGE_CHECK(n)\ |
|
| 661 |
{\
|
|
| 662 |
VP8Macroblock *edge = mb_edge[n];\ |
|
| 663 |
int edge_ref = edge->ref_frame;\ |
|
| 664 |
if (edge_ref != VP56_FRAME_CURRENT) {\
|
|
| 665 |
uint32_t mv = AV_RN32A(&edge->mv);\ |
|
| 666 |
if (mv) {\
|
|
| 667 |
if (cur_sign_bias != sign_bias[edge_ref]) {\
|
|
| 668 |
/* SWAR negate of the values in mv. */\ |
|
| 669 |
mv = ~mv;\ |
|
| 670 |
mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\ |
|
| 671 |
}\ |
|
| 672 |
if (!n || mv != AV_RN32A(&near_mv[idx]))\ |
|
| 673 |
AV_WN32A(&near_mv[++idx], mv);\ |
|
| 674 |
cnt[idx] += 1 + (n != 2);\ |
|
| 675 |
} else\ |
|
| 676 |
cnt[CNT_ZERO] += 1 + (n != 2);\ |
|
| 677 |
}\ |
|
| 678 |
} |
|
| 679 |
|
|
| 680 |
MV_EDGE_CHECK(0) |
|
| 681 |
MV_EDGE_CHECK(1) |
|
| 682 |
MV_EDGE_CHECK(2) |
|
| 683 |
|
|
| 684 |
mb->partitioning = VP8_SPLITMVMODE_NONE; |
|
| 685 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {
|
|
| 686 |
mb->mode = VP8_MVMODE_MV; |
|
| 687 |
|
|
| 688 |
/* If we have three distinct MVs, merge first and last if they're the same */ |
|
| 689 |
if (cnt[CNT_SPLITMV] && AV_RN32A(&near_mv[1+EDGE_TOP]) == AV_RN32A(&near_mv[1+EDGE_TOPLEFT])) |
|
| 690 |
cnt[CNT_NEAREST] += 1; |
|
| 691 |
|
|
| 692 |
/* Swap near and nearest if necessary */ |
|
| 693 |
if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
|
|
| 694 |
FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]); |
|
| 695 |
FFSWAP( VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]); |
|
| 696 |
} |
|
| 697 |
|
|
| 698 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
|
|
| 699 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
|
|
| 700 |
|
|
| 701 |
/* Choose the best mv out of 0,0 and the nearest mv */ |
|
| 702 |
clamp_mv(s, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])], mb_x, mb_y); |
|
| 703 |
cnt[CNT_SPLITMV] = ((mb_edge[EDGE_LEFT]->mode == VP8_MVMODE_SPLIT) + |
|
| 704 |
(mb_edge[EDGE_TOP]->mode == VP8_MVMODE_SPLIT)) * 2 + |
|
| 705 |
(mb_edge[EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT); |
|
| 706 |
|
|
| 707 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {
|
|
| 708 |
mb->mode = VP8_MVMODE_SPLIT; |
|
| 709 |
mb->mv = mb->bmv[decode_splitmvs(s, c, mb) - 1]; |
|
| 710 |
} else {
|
|
| 711 |
mb->mv.y += read_mv_component(c, s->prob->mvc[0]); |
|
| 712 |
mb->mv.x += read_mv_component(c, s->prob->mvc[1]); |
|
| 713 |
mb->bmv[0] = mb->mv; |
|
| 714 |
} |
|
| 715 |
} else {
|
|
| 716 |
clamp_mv(s, &mb->mv, &near_mv[CNT_NEAR], mb_x, mb_y); |
|
| 717 |
mb->bmv[0] = mb->mv; |
|
| 718 |
} |
|
| 719 |
} else {
|
|
| 720 |
clamp_mv(s, &mb->mv, &near_mv[CNT_NEAREST], mb_x, mb_y); |
|
| 721 |
mb->bmv[0] = mb->mv; |
|
| 722 |
} |
|
| 723 |
} else {
|
|
| 724 |
mb->mode = VP8_MVMODE_ZERO; |
|
| 725 |
AV_ZERO32(&mb->mv); |
|
| 726 |
mb->bmv[0] = mb->mv; |
|
| 727 |
} |
|
| 728 |
} |
|
| 729 |
|
|
| 730 |
static av_always_inline |
|
| 703 | 731 |
void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, |
| 704 | 732 |
int mb_x, int keyframe) |
| 705 | 733 |
{
|
| ... | ... | |
| 749 | 777 |
s->chroma_pred_mode = vp8_rac_get_tree(c, vp8_pred8x8c_tree, vp8_pred8x8c_prob_intra); |
| 750 | 778 |
mb->ref_frame = VP56_FRAME_CURRENT; |
| 751 | 779 |
} else if (vp56_rac_get_prob_branchy(c, s->prob->intra)) {
|
| 752 |
VP56mv near[2], best; |
|
| 753 |
uint8_t cnt[4] = { 0 };
|
|
| 754 |
|
|
| 755 | 780 |
// inter MB, 16.2 |
| 756 | 781 |
if (vp56_rac_get_prob_branchy(c, s->prob->last)) |
| 757 | 782 |
mb->ref_frame = vp56_rac_get_prob(c, s->prob->golden) ? |
| ... | ... | |
| 761 | 786 |
s->ref_count[mb->ref_frame-1]++; |
| 762 | 787 |
|
| 763 | 788 |
// motion vectors, 16.3 |
| 764 |
find_near_mvs(s, mb, near, &best, cnt); |
|
| 765 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[0]][0])) {
|
|
| 766 |
mb->mode = VP8_MVMODE_MV; |
|
| 767 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[1]][1])) {
|
|
| 768 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[2]][2])) {
|
|
| 769 |
if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[3]][3])) {
|
|
| 770 |
mb->mode = VP8_MVMODE_SPLIT; |
|
| 771 |
clamp_mv(s, &mb->mv, &mb->mv, mb_x, mb_y); |
|
| 772 |
mb->mv = mb->bmv[decode_splitmvs(s, c, mb) - 1]; |
|
| 773 |
} else {
|
|
| 774 |
clamp_mv(s, &mb->mv, &mb->mv, mb_x, mb_y); |
|
| 775 |
mb->mv.y += read_mv_component(c, s->prob->mvc[0]); |
|
| 776 |
mb->mv.x += read_mv_component(c, s->prob->mvc[1]); |
|
| 777 |
} |
|
| 778 |
} else |
|
| 779 |
clamp_mv(s, &mb->mv, &near[1], mb_x, mb_y); |
|
| 780 |
} else |
|
| 781 |
clamp_mv(s, &mb->mv, &near[0], mb_x, mb_y); |
|
| 782 |
} else {
|
|
| 783 |
mb->mode = VP8_MVMODE_ZERO; |
|
| 784 |
AV_ZERO32(&mb->mv); |
|
| 785 |
} |
|
| 786 |
if (mb->mode != VP8_MVMODE_SPLIT) {
|
|
| 787 |
mb->partitioning = VP8_SPLITMVMODE_NONE; |
|
| 788 |
mb->bmv[0] = mb->mv; |
|
| 789 |
} |
|
| 789 |
decode_mvs(s, mb, mb_x, mb_y); |
|
| 790 | 790 |
} else {
|
| 791 | 791 |
// intra MB, 16.1 |
| 792 | 792 |
mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_inter, s->prob->pred16x16); |
Also available in: Unified diff