← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libav/utopic-proposed

« back to all changes in this revision

Viewing changes to libavcodec/hevc_mvs.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler, Reinhard Tartler, Rico Tzschichholz
  • Date: 2014-08-30 11:02:45 UTC
  • mfrom: (1.3.47 sid)
  • Revision ID: package-import@ubuntu.com-20140830110245-io3dg7q85wfr7125
Tags: 6:11~beta1-2
[ Reinhard Tartler ]
* Make libavcodec-dev depend on libavresample-dev

[ Rico Tzschichholz ]
* Some fixes and leftovers from soname bumps

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/hevc_mvs.c
118
118
           yN >> plevel == yP >> plevel;
119
119
}
120
120
 
 
121
#define MATCH_MV(x) (AV_RN32A(&A.x) == AV_RN32A(&B.x))
121
122
#define MATCH(x) (A.x == B.x)
122
123
 
123
124
// check if the mv's and refidx are the same between A and B
124
125
static int compareMVrefidx(struct MvField A, struct MvField B)
125
126
{
126
127
    if (A.pred_flag[0] && A.pred_flag[1] && B.pred_flag[0] && B.pred_flag[1])
127
 
        return MATCH(ref_idx[0]) && MATCH(mv[0].x) && MATCH(mv[0].y) &&
128
 
               MATCH(ref_idx[1]) && MATCH(mv[1].x) && MATCH(mv[1].y);
 
128
        return MATCH(ref_idx[0]) && MATCH_MV(mv[0]) &&
 
129
               MATCH(ref_idx[1]) && MATCH_MV(mv[1]);
129
130
 
130
131
    if (A.pred_flag[0] && !A.pred_flag[1] && B.pred_flag[0] && !B.pred_flag[1])
131
 
        return MATCH(ref_idx[0]) && MATCH(mv[0].x) && MATCH(mv[0].y);
 
132
        return MATCH(ref_idx[0]) && MATCH_MV(mv[0]);
132
133
 
133
134
    if (!A.pred_flag[0] && A.pred_flag[1] && !B.pred_flag[0] && B.pred_flag[1])
134
 
        return MATCH(ref_idx[1]) && MATCH(mv[1].x) && MATCH(mv[1].y);
 
135
        return MATCH(ref_idx[1]) && MATCH_MV(mv[1]);
135
136
 
136
137
    return 0;
137
138
}
266
267
    x = x0 + nPbW;
267
268
    y = y0 + nPbH;
268
269
 
269
 
    ff_thread_await_progress(&ref->tf, y, 0);
270
270
    if (tab_mvf &&
271
271
        (y0 >> s->sps->log2_ctb_size) == (y >> s->sps->log2_ctb_size) &&
272
272
        y < s->sps->height &&
273
273
        x < s->sps->width) {
274
 
        x                  = ((x >> 4) << 4);
275
 
        y                  = ((y >> 4) << 4);
 
274
        x                 &= ~15;
 
275
        y                 &= ~15;
 
276
        ff_thread_await_progress(&ref->tf, y, 0);
276
277
        x_pu               = x >> s->sps->log2_min_pu_size;
277
278
        y_pu               = y >> s->sps->log2_min_pu_size;
278
279
        temp_col           = TAB_MVF(x_pu, y_pu);
283
284
    if (tab_mvf && !availableFlagLXCol) {
284
285
        x                  = x0 + (nPbW >> 1);
285
286
        y                  = y0 + (nPbH >> 1);
286
 
        x                  = ((x >> 4) << 4);
287
 
        y                  = ((y >> 4) << 4);
 
287
        x                 &= ~15;
 
288
        y                 &= ~15;
 
289
        ff_thread_await_progress(&ref->tf, y, 0);
288
290
        x_pu               = x >> s->sps->log2_min_pu_size;
289
291
        y_pu               = y >> s->sps->log2_min_pu_size;
290
292
        temp_col           = TAB_MVF(x_pu, y_pu);
311
313
                                            int nPbW, int nPbH,
312
314
                                            int log2_cb_size,
313
315
                                            int singleMCLFlag, int part_idx,
 
316
                                            int merge_idx,
314
317
                                            struct MvField mergecandlist[])
315
318
{
316
319
    HEVCLocalContext *lc   = &s->HEVClc;
379
382
        is_available_a1 = 0;
380
383
    }
381
384
 
382
 
    if (is_available_a1)
383
 
        mergecandlist[nb_merge_cand++] = TAB_MVF_PU(A1);
 
385
    if (is_available_a1) {
 
386
        mergecandlist[0] = TAB_MVF_PU(A1);
 
387
        if (merge_idx == 0)
 
388
            return;
 
389
        nb_merge_cand++;
 
390
    }
384
391
 
385
392
    // above spatial merge candidate
386
393
    is_available_b1 = AVAILABLE(cand_up, B1);
411
418
    if (is_available_b1 && is_available_b0)
412
419
        check_MER = !COMPARE_MV_REFIDX(B0, B1);
413
420
 
414
 
    if (is_available_b0 && check_MER)
415
 
        mergecandlist[nb_merge_cand++] = TAB_MVF_PU(B0);
 
421
    if (is_available_b0 && check_MER) {
 
422
        mergecandlist[nb_merge_cand] = TAB_MVF_PU(B0);
 
423
        if (merge_idx == nb_merge_cand)
 
424
            return;
 
425
        nb_merge_cand++;
 
426
    }
416
427
 
417
428
    // left bottom spatial merge candidate
418
429
    check_MER = 1;
426
437
    if (is_available_a1 && is_available_a0)
427
438
        check_MER = !COMPARE_MV_REFIDX(A0, A1);
428
439
 
429
 
    if (is_available_a0 && check_MER)
430
 
        mergecandlist[nb_merge_cand++] = TAB_MVF_PU(A0);
 
440
    if (is_available_a0 && check_MER) {
 
441
        mergecandlist[nb_merge_cand] = TAB_MVF_PU(A0);
 
442
        if (merge_idx == nb_merge_cand)
 
443
            return;
 
444
        nb_merge_cand++;
 
445
    }
431
446
 
432
447
    // above left spatial merge candidate
433
448
    check_MER = 1;
443
458
    if (is_available_b1 && is_available_b2)
444
459
        check_MER_1 = !COMPARE_MV_REFIDX(B2, B1);
445
460
 
446
 
    if (is_available_b2 && check_MER && check_MER_1 && nb_merge_cand != 4)
447
 
        mergecandlist[nb_merge_cand++] = TAB_MVF_PU(B2);
 
461
    if (is_available_b2 && check_MER && check_MER_1 && nb_merge_cand != 4) {
 
462
        mergecandlist[nb_merge_cand] = TAB_MVF_PU(B2);
 
463
        if (merge_idx == nb_merge_cand)
 
464
            return;
 
465
        nb_merge_cand++;
 
466
    }
448
467
 
449
468
    // temporal motion vector candidate
450
469
    if (s->sh.slice_temporal_mvp_enabled_flag &&
468
487
                mergecandlist[nb_merge_cand].mv[1]      = mv_l1_col;
469
488
                mergecandlist[nb_merge_cand].ref_idx[1] = 0;
470
489
            }
 
490
            if (merge_idx == nb_merge_cand)
 
491
                return;
471
492
            nb_merge_cand++;
472
493
        }
473
494
    }
489
510
            if (l0_cand.pred_flag[0] && l1_cand.pred_flag[1] &&
490
511
                (refPicList[0].list[l0_cand.ref_idx[0]] !=
491
512
                 refPicList[1].list[l1_cand.ref_idx[1]] ||
492
 
                 l0_cand.mv[0].x != l1_cand.mv[1].x ||
493
 
                 l0_cand.mv[0].y != l1_cand.mv[1].y)) {
 
513
                 AV_RN32A(&l0_cand.mv[0]) != AV_RN32A(&l1_cand.mv[1]))) {
494
514
                mergecandlist[nb_merge_cand].ref_idx[0]   = l0_cand.ref_idx[0];
495
515
                mergecandlist[nb_merge_cand].ref_idx[1]   = l1_cand.ref_idx[1];
496
516
                mergecandlist[nb_merge_cand].pred_flag[0] = 1;
497
517
                mergecandlist[nb_merge_cand].pred_flag[1] = 1;
498
 
                mergecandlist[nb_merge_cand].mv[0].x      = l0_cand.mv[0].x;
499
 
                mergecandlist[nb_merge_cand].mv[0].y      = l0_cand.mv[0].y;
500
 
                mergecandlist[nb_merge_cand].mv[1].x      = l1_cand.mv[1].x;
501
 
                mergecandlist[nb_merge_cand].mv[1].y      = l1_cand.mv[1].y;
 
518
                AV_COPY32(&mergecandlist[nb_merge_cand].mv[0], &l0_cand.mv[0]);
 
519
                AV_COPY32(&mergecandlist[nb_merge_cand].mv[1], &l1_cand.mv[1]);
502
520
                mergecandlist[nb_merge_cand].is_intra     = 0;
 
521
                if (merge_idx == nb_merge_cand)
 
522
                    return;
503
523
                nb_merge_cand++;
504
524
            }
505
525
        }
509
529
    while (nb_merge_cand < s->sh.max_num_merge_cand) {
510
530
        mergecandlist[nb_merge_cand].pred_flag[0] = 1;
511
531
        mergecandlist[nb_merge_cand].pred_flag[1] = s->sh.slice_type == B_SLICE;
512
 
        mergecandlist[nb_merge_cand].mv[0].x      = 0;
513
 
        mergecandlist[nb_merge_cand].mv[0].y      = 0;
514
 
        mergecandlist[nb_merge_cand].mv[1].x      = 0;
515
 
        mergecandlist[nb_merge_cand].mv[1].y      = 0;
 
532
        AV_ZERO32(mergecandlist[nb_merge_cand].mv + 0);
 
533
        AV_ZERO32(mergecandlist[nb_merge_cand].mv + 1);
516
534
        mergecandlist[nb_merge_cand].is_intra     = 0;
517
535
        mergecandlist[nb_merge_cand].ref_idx[0]   = zero_idx < nb_refs ? zero_idx : 0;
518
536
        mergecandlist[nb_merge_cand].ref_idx[1]   = zero_idx < nb_refs ? zero_idx : 0;
519
537
 
 
538
        if (merge_idx == nb_merge_cand)
 
539
            return;
520
540
        nb_merge_cand++;
521
541
        zero_idx++;
522
542
    }
531
551
{
532
552
    int singleMCLFlag = 0;
533
553
    int nCS = 1 << log2_cb_size;
534
 
    struct MvField mergecand_list[MRG_MAX_NUM_CANDS] = { { { { 0 } } } };
 
554
    LOCAL_ALIGNED(4, MvField, mergecand_list, [MRG_MAX_NUM_CANDS]);
535
555
    int nPbW2 = nPbW;
536
556
    int nPbH2 = nPbH;
537
557
    HEVCLocalContext *lc = &s->HEVClc;
547
567
 
548
568
    ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
549
569
    derive_spatial_merge_candidates(s, x0, y0, nPbW, nPbH, log2_cb_size,
550
 
                                    singleMCLFlag, part_idx, mergecand_list);
 
570
                                    singleMCLFlag, part_idx,
 
571
                                    merge_idx, mergecand_list);
551
572
 
552
573
    if (mergecand_list[merge_idx].pred_flag[0] == 1 &&
553
574
        mergecand_list[merge_idx].pred_flag[1] == 1 &&
722
743
            availableFlagLXA0 = MP_MX_LT(A1, pred_flag_index_l1, mxA);
723
744
    }
724
745
 
 
746
    if (availableFlagLXA0 && !mvp_lx_flag) {
 
747
        mv->mv[LX] = mxA;
 
748
        return;
 
749
    }
 
750
 
725
751
    // B candidates
726
752
    // above right spatial merge candidate
727
753
    xB0    = x0 + nPbW;
802
828
        mvpcand_list[numMVPCandLX++] = mxB;
803
829
 
804
830
    //temporal motion vector prediction candidate
805
 
    if (numMVPCandLX < 2 && s->sh.slice_temporal_mvp_enabled_flag) {
 
831
    if (numMVPCandLX < 2 && s->sh.slice_temporal_mvp_enabled_flag &&
 
832
        mvp_lx_flag == numMVPCandLX) {
806
833
        Mv mv_col;
807
834
        int available_col = temporal_luma_motion_vector(s, x0, y0, nPbW,
808
835
                                                        nPbH, ref_idx,