falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
57330 Commits
32 Branches
313MB
Tree: 0c8aba3842
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0c8aba3842'
${ noResults }
FFmpeg/libavcodec/hevc_mvs.c

1009 lines
32KB
Raw Blame History 

  1. /*

  2.  * HEVC video Decoder

  3.  *

  4.  * Copyright (C) 2012 - 2013 Guillaume Martres

  5.  * Copyright (C) 2013 Anand Meher Kotra

  6.  *

  7.  * This file is part of FFmpeg.

  8.  *

  9.  * FFmpeg is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * FFmpeg is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with FFmpeg; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  */

  23. 

  24. #include "hevc.h"

  25. 

  26. static const uint8_t l0_l1_cand_idx[12][2] = {

  27.     { 0, 1, },

  28.     { 1, 0, },

  29.     { 0, 2, },

  30.     { 2, 0, },

  31.     { 1, 2, },

  32.     { 2, 1, },

  33.     { 0, 3, },

  34.     { 3, 0, },

  35.     { 1, 3, },

  36.     { 3, 1, },

  37.     { 2, 3, },

  38.     { 3, 2, },

  39. };

  40. 

  41. void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, int nPbW, int nPbH)

  42. {

  43.     HEVCLocalContext *lc = s->HEVClc;

  44.     int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);

  45.     int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);

  46. 

  47.     lc->na.cand_up       = (lc->ctb_up_flag   || y0b);

  48.     lc->na.cand_left     = (lc->ctb_left_flag || x0b);

  49.     lc->na.cand_up_left  = (!x0b && !y0b) ? lc->ctb_up_left_flag : lc->na.cand_left && lc->na.cand_up;

  50.     lc->na.cand_up_right_sap =

  51.             ((x0b + nPbW) == (1 << s->sps->log2_ctb_size)) ?

  52.                     lc->ctb_up_right_flag && !y0b : lc->na.cand_up;

  53.     lc->na.cand_up_right =

  54.             ((x0b + nPbW) == (1 << s->sps->log2_ctb_size) ?

  55.                     lc->ctb_up_right_flag && !y0b : lc->na.cand_up )

  56.                      && (x0 + nPbW) < lc->end_of_tiles_x;

  57.     lc->na.cand_bottom_left = ((y0 + nPbH) >= lc->end_of_tiles_y) ? 0 : lc->na.cand_left;

  58. }

  59. 

  60. /*

  61.  * 6.4.1 Derivation process for z-scan order block availability

  62.  */

  63. static int z_scan_block_avail(HEVCContext *s, int xCurr, int yCurr,

  64.                               int xN, int yN)

  65. {

  66. #define MIN_TB_ADDR_ZS(x, y)                                            \

  67.     s->pps->min_tb_addr_zs[(y) * s->sps->min_tb_width + (x)]

  68.     int Curr =  MIN_TB_ADDR_ZS(xCurr >> s->sps->log2_min_transform_block_size,

  69.                                yCurr >> s->sps->log2_min_transform_block_size);

  70.     int N;

  71. 

  72.     if ((xN < 0) || (yN < 0) ||

  73.         (xN >= s->sps->width) ||

  74.         (yN >= s->sps->height))

  75.         return 0;

  76. 

  77.     N = MIN_TB_ADDR_ZS(xN >> s->sps->log2_min_transform_block_size,

  78.                        yN >> s->sps->log2_min_transform_block_size);

  79. 

  80.     return N <= Curr;

  81. }

  82. 

  83. 

  84. static int same_prediction_block(HEVCLocalContext *lc, int log2_cb_size,

  85.                                  int x0, int y0, int nPbW, int nPbH,

  86.                                  int xA1, int yA1, int partIdx)

  87. {

  88.     return !(nPbW << 1 == 1 << log2_cb_size &&

  89.              nPbH << 1 == 1 << log2_cb_size && partIdx == 1 &&

  90.              lc->cu.x + nPbW > xA1 &&

  91.              lc->cu.y + nPbH <= yA1);

  92. }

  93. 

  94. /*

  95.  * 6.4.2 Derivation process for prediction block availability

  96.  */

  97. static int check_prediction_block_available(HEVCContext *s, int log2_cb_size,

  98.                                             int x0, int y0, int nPbW, int nPbH,

  99.                                             int xA1, int yA1, int partIdx)

  100. {

  101.     HEVCLocalContext *lc = s->HEVClc;

  102. 

  103.     if (lc->cu.x < xA1 && lc->cu.y < yA1 &&

  104.         (lc->cu.x + (1 << log2_cb_size)) > xA1 &&

  105.         (lc->cu.y + (1 << log2_cb_size)) > yA1)

  106.         return same_prediction_block(lc, log2_cb_size, x0, y0,

  107.                                      nPbW, nPbH, xA1, yA1, partIdx);

  108.     else

  109.         return z_scan_block_avail(s, x0, y0, xA1, yA1);

  110. }

  111. 

  112. //check if the two luma locations belong to the same mostion estimation region

  113. static int isDiffMER(HEVCContext *s, int xN, int yN, int xP, int yP)

  114. {

  115.     uint8_t plevel = s->pps->log2_parallel_merge_level;

  116. 

  117.     return xN >> plevel == xP >> plevel &&

  118.            yN >> plevel == yP >> plevel;

  119. }

  120. 

  121. #define MATCH(x) (A.x == B.x)

  122. 

  123. // check if the mv's and refidx are the same between A and B

  124. static int compareMVrefidx(struct MvField A, struct MvField B)

  125. {

  126.     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);

  129. 

  130.     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. 

  133.     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. 

  136.     return 0;

  137. }

  138. 

  139. static av_always_inline void mv_scale(Mv *dst, Mv *src, int td, int tb)

  140. {

  141.     int tx, scale_factor;

  142. 

  143.     td = av_clip_int8_c(td);

  144.     tb = av_clip_int8_c(tb);

  145.     tx = (0x4000 + abs(td / 2)) / td;

  146.     scale_factor = av_clip_c((tb * tx + 32) >> 6, -4096, 4095);

  147.     dst->x = av_clip_int16_c((scale_factor * src->x + 127 +

  148.                              (scale_factor * src->x < 0)) >> 8);

  149.     dst->y = av_clip_int16_c((scale_factor * src->y + 127 +

  150.                              (scale_factor * src->y < 0)) >> 8);

  151. }

  152. 

  153. static int check_mvset(Mv *mvLXCol, Mv *mvCol,

  154.                        int colPic, int poc,

  155.                        RefPicList *refPicList, int X, int refIdxLx,

  156.                        RefPicList *refPicList_col, int listCol, int refidxCol)

  157. {

  158.     int cur_lt = refPicList[X].isLongTerm[refIdxLx];

  159.     int col_lt = refPicList_col[listCol].isLongTerm[refidxCol];

  160.     int col_poc_diff, cur_poc_diff;

  161. 

  162.     if (cur_lt != col_lt) {

  163.         mvLXCol->x = 0;

  164.         mvLXCol->y = 0;

  165.         return 0;

  166.     }

  167. 

  168.     col_poc_diff = colPic - refPicList_col[listCol].list[refidxCol];

  169.     cur_poc_diff = poc    - refPicList[X].list[refIdxLx];

  170. 

  171.     if (!col_poc_diff)

  172.         col_poc_diff = 1; // error resilience

  173. 

  174.     if (cur_lt || col_poc_diff == cur_poc_diff) {

  175.         mvLXCol->x = mvCol->x;

  176.         mvLXCol->y = mvCol->y;

  177.     } else {

  178.         mv_scale(mvLXCol, mvCol, col_poc_diff, cur_poc_diff);

  179.     }

  180.     return 1;

  181. }

  182. 

  183. #define CHECK_MVSET(l) \

  184.     check_mvset(mvLXCol, temp_col.mv + l, \

  185.                 colPic, s->poc, \

  186.                 refPicList, X, refIdxLx, \

  187.                 refPicList_col, L##l, temp_col.ref_idx[l])

  188. 

  189. // derive the motion vectors section 8.5.3.1.8

  190. static int derive_temporal_colocated_mvs(HEVCContext *s, MvField temp_col,

  191.                                          int refIdxLx, Mv* mvLXCol, int X,

  192.                                          int colPic, RefPicList* refPicList_col)

  193. {

  194.     RefPicList *refPicList = s->ref->refPicList;

  195. 

  196.     if (temp_col.is_intra) {

  197.         mvLXCol->x = 0;

  198.         mvLXCol->y = 0;

  199.         return 0;

  200.     }

  201. 

  202.     if (temp_col.pred_flag[0] == 0)

  203.         return CHECK_MVSET(1);

  204.     else if (temp_col.pred_flag[0] == 1 && temp_col.pred_flag[1] == 0)

  205.         return CHECK_MVSET(0);

  206.     else if (temp_col.pred_flag[0] == 1 && temp_col.pred_flag[1] == 1) {

  207.         int check_diffpicount = 0;

  208.         int i = 0;

  209.         for (i = 0; i < refPicList[0].nb_refs; i++) {

  210.             if (refPicList[0].list[i] > s->poc)

  211.                 check_diffpicount++;

  212.         }

  213.         for (i = 0; i < refPicList[1].nb_refs; i++) {

  214.             if (refPicList[1].list[i] > s->poc)

  215.                 check_diffpicount++;

  216.         }

  217.         if (check_diffpicount == 0 && X == 0)

  218.             return CHECK_MVSET(0);

  219.         else if (check_diffpicount == 0 && X == 1)

  220.             return CHECK_MVSET(1);

  221.         else {

  222.             if (s->sh.collocated_list == L1)

  223.                 return CHECK_MVSET(0);

  224.             else

  225.                 return CHECK_MVSET(1);

  226.         }

  227.     }

  228. 

  229.     return 0;

  230. }

  231. 

  232. #define TAB_MVF(x, y) \

  233.     tab_mvf[(y) * pic_width_in_min_pu + x]

  234. 

  235. #define TAB_MVF_PU(v) \

  236.     TAB_MVF(x##v##_pu, y##v##_pu)

  237. 

  238. #define DERIVE_TEMPORAL_COLOCATED_MVS(v) \

  239.     derive_temporal_colocated_mvs(s, temp_col, \

  240.                                   refIdxLx, mvLXCol, X, colPic, \

  241.                                   ff_hevc_get_ref_list(s, ref, \

  242.                                                        x##v, y##v))

  243. 

  244. /*

  245.  * 8.5.3.1.7  temporal luma motion vector prediction

  246.  */

  247. static int temporal_luma_motion_vector(HEVCContext *s, int x0, int y0,

  248.                                        int nPbW, int nPbH, int refIdxLx,

  249.                                        Mv* mvLXCol, int X)

  250. {

  251.     MvField *tab_mvf;

  252.     MvField temp_col;

  253.     int xPRb, yPRb;

  254.     int xPRb_pu;

  255.     int yPRb_pu;

  256.     int xPCtr, yPCtr;

  257.     int xPCtr_pu;

  258.     int yPCtr_pu;

  259.     int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size;

  260.     int availableFlagLXCol = 0;

  261.     int colPic;

  262. 

  263.     HEVCFrame *ref = s->ref->collocated_ref;

  264. 

  265.     if (!ref)

  266.         return 0;

  267. 

  268.     tab_mvf = ref->tab_mvf;

  269.     colPic  = ref->poc;

  270. 

  271.     //bottom right collocated motion vector

  272.     xPRb = x0 + nPbW;

  273.     yPRb = y0 + nPbH;

  274. 

  275.     if (s->threads_type == FF_THREAD_FRAME )

  276.         ff_thread_await_progress(&ref->tf, INT_MAX, 0);

  277.     if (tab_mvf &&

  278.         y0 >> s->sps->log2_ctb_size == yPRb >> s->sps->log2_ctb_size &&

  279.         yPRb < s->sps->height &&

  280.         xPRb < s->sps->width) {

  281.         xPRb = ((xPRb >> 4) << 4);

  282.         yPRb = ((yPRb >> 4) << 4);

  283.         xPRb_pu = xPRb >> s->sps->log2_min_pu_size;

  284.         yPRb_pu = yPRb >> s->sps->log2_min_pu_size;

  285.         temp_col = TAB_MVF_PU(PRb);

  286.         availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(PRb);

  287.     } else {

  288.         mvLXCol->x = 0;

  289.         mvLXCol->y = 0;

  290.         availableFlagLXCol = 0;

  291.     }

  292. 

  293.     // derive center collocated motion vector

  294.     if (tab_mvf && availableFlagLXCol == 0) {

  295.         xPCtr = x0 + (nPbW >> 1);

  296.         yPCtr = y0 + (nPbH >> 1);

  297.         xPCtr = ((xPCtr >> 4) << 4);

  298.         yPCtr = ((yPCtr >> 4) << 4);

  299.         xPCtr_pu = xPCtr >> s->sps->log2_min_pu_size;

  300.         yPCtr_pu = yPCtr >> s->sps->log2_min_pu_size;

  301.         temp_col = TAB_MVF_PU(PCtr);

  302.         availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(PCtr);

  303.     }

  304.     return availableFlagLXCol;

  305. }

  306. 

  307. #define AVAILABLE(cand, v) \

  308.     (cand && !TAB_MVF_PU(v).is_intra)

  309. 

  310. #define PRED_BLOCK_AVAILABLE(v) \

  311.     check_prediction_block_available(s, log2_cb_size, \

  312.                                      x0, y0, nPbW, nPbH, \

  313.                                      x##v, y##v, part_idx)

  314. 

  315. #define COMPARE_MV_REFIDX(a, b) \

  316.     compareMVrefidx(TAB_MVF_PU(a), TAB_MVF_PU(b))

  317. 

  318. /*

  319.  * 8.5.3.1.2  Derivation process for spatial merging candidates

  320.  */

  321. static void derive_spatial_merge_candidates(HEVCContext *s, int x0, int y0,

  322.                                             int nPbW, int nPbH, int log2_cb_size,

  323.                                             int singleMCLFlag, int part_idx,

  324.                                             struct MvField mergecandlist[])

  325. {

  326.     HEVCLocalContext *lc = s->HEVClc;

  327.     RefPicList *refPicList = s->ref->refPicList;

  328.     MvField *tab_mvf = s->ref->tab_mvf;

  329. 

  330.     int available_a1_flag = 0;

  331.     int available_b1_flag = 0;

  332.     int available_b0_flag = 0;

  333.     int available_a0_flag = 0;

  334.     int available_b2_flag = 0;

  335.     struct MvField spatialCMVS[MRG_MAX_NUM_CANDS];

  336.     struct MvField combCand = { { { 0 } } };

  337.     struct MvField TMVPCand = { { { 0 } } };

  338.     struct Mv mvL0Col = { 0 };

  339.     struct Mv mvL1Col = { 0 };

  340. 

  341.     //first left spatial merge candidate

  342.     int xA1 = x0 - 1;

  343.     int yA1 = y0 + nPbH - 1;

  344.     int is_available_a1;

  345.     int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size;

  346. 

  347.     int check_MER = 1;

  348.     int check_MER_1 = 1;

  349. 

  350.     int xB1, yB1;

  351.     int is_available_b1;

  352.     int xB1_pu;

  353.     int yB1_pu;

  354. 

  355.     int check_B0;

  356.     int xB0, yB0;

  357.     int isAvailableB0;

  358.     int xB0_pu;

  359.     int yB0_pu;

  360. 

  361.     int check_A0;

  362.     int xA0, yA0;

  363.     int is_available_a0;

  364.     int xA0_pu;

  365.     int yA0_pu;

  366. 

  367.     int xB2, yB2;

  368.     int isAvailableB2;

  369.     int xB2_pu;

  370.     int yB2_pu;

  371.     int mergearray_index = 0;

  372. 

  373.     struct MvField zerovector;

  374.     int numRefIdx = 0;

  375.     int zeroIdx = 0;

  376. 

  377.     int numMergeCand = 0;

  378.     int numOrigMergeCand = 0;

  379.     int sumcandidates = 0;

  380.     int combIdx = 0;

  381.     int combStop = 0;

  382.     int l0CandIdx = 0;

  383.     int l1CandIdx = 0;

  384. 

  385.     int refIdxL0Col = 0;

  386.     int refIdxL1Col = 0;

  387.     int availableFlagLXCol = 0;

  388. 

  389.     int cand_bottom_left = lc->na.cand_bottom_left;

  390.     int cand_left        = lc->na.cand_left;

  391.     int cand_up_left     = lc->na.cand_up_left;

  392.     int cand_up          = lc->na.cand_up;

  393.     int cand_up_right    = lc->na.cand_up_right_sap;

  394. 

  395. 

  396.     int xA1_pu = xA1 >> s->sps->log2_min_pu_size;

  397.     int yA1_pu = yA1 >> s->sps->log2_min_pu_size;

  398. 

  399.     int availableFlagL0Col = 0;

  400.     int availableFlagL1Col = 0;

  401. 

  402.     is_available_a1 = AVAILABLE(cand_left, A1);

  403. 

  404.     if (!singleMCLFlag && part_idx == 1 &&

  405.         (lc->cu.part_mode == PART_Nx2N ||

  406.          lc->cu.part_mode == PART_nLx2N ||

  407.          lc->cu.part_mode == PART_nRx2N) ||

  408.         isDiffMER(s, xA1, yA1, x0, y0)) {

  409.         is_available_a1 = 0;

  410.     }

  411. 

  412.     if (is_available_a1) {

  413.         available_a1_flag = 1;

  414.         spatialCMVS[0] = TAB_MVF_PU(A1);

  415.     } else {

  416.         available_a1_flag = 0;

  417.         spatialCMVS[0].ref_idx[0] = -1;

  418.         spatialCMVS[0].ref_idx[1] = -1;

  419.         spatialCMVS[0].mv[0].x = 0;

  420.         spatialCMVS[0].mv[0].y = 0;

  421.         spatialCMVS[0].mv[1].x = 0;

  422.         spatialCMVS[0].mv[1].y = 0;

  423.         spatialCMVS[0].pred_flag[0] = 0;

  424.         spatialCMVS[0].pred_flag[1] = 0;

  425.         spatialCMVS[0].is_intra = 0;

  426.     }

  427. 

  428.     // above spatial merge candidate

  429. 

  430.     xB1 = x0 + nPbW - 1;

  431.     yB1 = y0 - 1;

  432.     xB1_pu = xB1 >> s->sps->log2_min_pu_size;

  433.     yB1_pu = yB1 >> s->sps->log2_min_pu_size;

  434. 

  435.     is_available_b1 = AVAILABLE(cand_up, B1);

  436. 

  437.     if (!singleMCLFlag && part_idx == 1 &&

  438.         (lc->cu.part_mode == PART_2NxN ||

  439.          lc->cu.part_mode == PART_2NxnU ||

  440.          lc->cu.part_mode == PART_2NxnD) ||

  441.         isDiffMER(s, xB1, yB1, x0, y0)) {

  442.         is_available_b1 = 0;

  443.     }

  444. 

  445.     if (is_available_a1 && is_available_b1)

  446.         check_MER = !COMPARE_MV_REFIDX(B1, A1);

  447. 

  448.     if (is_available_b1 && check_MER) {

  449.         available_b1_flag = 1;

  450.         spatialCMVS[1] = TAB_MVF_PU(B1);

  451.     } else {

  452.         available_b1_flag = 0;

  453.         spatialCMVS[1].ref_idx[0] = -1;

  454.         spatialCMVS[1].ref_idx[1] = -1;

  455.         spatialCMVS[1].mv[0].x = 0;

  456.         spatialCMVS[1].mv[0].y = 0;

  457.         spatialCMVS[1].mv[1].x = 0;

  458.         spatialCMVS[1].mv[1].y = 0;

  459.         spatialCMVS[1].pred_flag[0] = 0;

  460.         spatialCMVS[1].pred_flag[1] = 0;

  461.         spatialCMVS[1].is_intra = 0;

  462.     }

  463. 

  464.     // above right spatial merge candidate

  465.     xB0 = x0 + nPbW;

  466.     yB0 = y0 - 1;

  467.     check_MER = 1;

  468.     xB0_pu = xB0 >> s->sps->log2_min_pu_size;

  469.     yB0_pu = yB0 >> s->sps->log2_min_pu_size;

  470.     check_B0 = PRED_BLOCK_AVAILABLE(B0);

  471. 

  472.     isAvailableB0 = check_B0 && AVAILABLE(cand_up_right, B0);

  473. 

  474.     if (isDiffMER(s, xB0, yB0, x0, y0))

  475.         isAvailableB0 = 0;

  476. 

  477.     if (is_available_b1 && isAvailableB0)

  478.         check_MER = !COMPARE_MV_REFIDX(B0, B1);

  479. 

  480.     if (isAvailableB0 && check_MER) {

  481.         available_b0_flag = 1;

  482.         spatialCMVS[2] = TAB_MVF_PU(B0);

  483.     } else {

  484.         available_b0_flag = 0;

  485.         spatialCMVS[2].ref_idx[0] = -1;

  486.         spatialCMVS[2].ref_idx[1] = -1;

  487.         spatialCMVS[2].mv[0].x = 0;

  488.         spatialCMVS[2].mv[0].y = 0;

  489.         spatialCMVS[2].mv[1].x = 0;

  490.         spatialCMVS[2].mv[1].y = 0;

  491.         spatialCMVS[2].pred_flag[0] = 0;

  492.         spatialCMVS[2].pred_flag[1] = 0;

  493.         spatialCMVS[2].is_intra = 0;

  494.     }

  495. 

  496.     // left bottom spatial merge candidate

  497.     xA0 = x0 - 1;

  498.     yA0 = y0 + nPbH;

  499.     check_MER = 1;

  500.     xA0_pu = xA0 >> s->sps->log2_min_pu_size;

  501.     yA0_pu = yA0 >> s->sps->log2_min_pu_size;

  502.     check_A0 = PRED_BLOCK_AVAILABLE(A0);

  503. 

  504.     is_available_a0 = check_A0 && AVAILABLE(cand_bottom_left, A0);

  505. 

  506.     if (isDiffMER(s, xA0, yA0, x0, y0))

  507.         is_available_a0 = 0;

  508. 

  509.     if (is_available_a1 && is_available_a0)

  510.         check_MER = !COMPARE_MV_REFIDX(A0, A1);

  511. 

  512.     if (is_available_a0 && check_MER) {

  513.         available_a0_flag = 1;

  514.         spatialCMVS[3] = TAB_MVF_PU(A0);

  515.     } else {

  516.         available_a0_flag = 0;

  517.         spatialCMVS[3].ref_idx[0] = -1;

  518.         spatialCMVS[3].ref_idx[1] = -1;

  519.         spatialCMVS[3].mv[0].x = 0;

  520.         spatialCMVS[3].mv[0].y = 0;

  521.         spatialCMVS[3].mv[1].x = 0;

  522.         spatialCMVS[3].mv[1].y = 0;

  523.         spatialCMVS[3].pred_flag[0] = 0;

  524.         spatialCMVS[3].pred_flag[1] = 0;

  525.         spatialCMVS[3].is_intra = 0;

  526.     }

  527. 

  528.     // above left spatial merge candidate

  529.     xB2 = x0 - 1;

  530.     yB2 = y0 - 1;

  531.     check_MER = 1;

  532.     xB2_pu = xB2 >> s->sps->log2_min_pu_size;

  533.     yB2_pu = yB2 >> s->sps->log2_min_pu_size;

  534. 

  535.     isAvailableB2 = AVAILABLE(cand_up_left, B2);

  536. 

  537.     if (isDiffMER(s, xB2, yB2, x0, y0))

  538.         isAvailableB2 = 0;

  539. 

  540.     if (is_available_a1 && isAvailableB2)

  541.         check_MER = !COMPARE_MV_REFIDX(B2, A1);

  542. 

  543.     if (is_available_b1 && isAvailableB2)

  544.         check_MER_1 = !COMPARE_MV_REFIDX(B2, B1);

  545. 

  546.     sumcandidates = available_a1_flag + available_b1_flag + available_b0_flag

  547.             + available_a0_flag;

  548. 

  549.     if (isAvailableB2 && check_MER && check_MER_1 && sumcandidates != 4) {

  550.         available_b2_flag = 1;

  551.         spatialCMVS[4] = TAB_MVF_PU(B2);

  552.     } else {

  553.         available_b2_flag = 0;

  554.         spatialCMVS[4].ref_idx[0] = -1;

  555.         spatialCMVS[4].ref_idx[1] = -1;

  556.         spatialCMVS[4].mv[0].x = 0;

  557.         spatialCMVS[4].mv[0].y = 0;

  558.         spatialCMVS[4].mv[1].x = 0;

  559.         spatialCMVS[4].mv[1].y = 0;

  560.         spatialCMVS[4].pred_flag[0] = 0;

  561.         spatialCMVS[4].pred_flag[1] = 0;

  562.         spatialCMVS[4].is_intra = 0;

  563.     }

  564. 

  565.     // temporal motion vector candidate

  566.     // one optimization is that do temporal checking only if the number of

  567.     // available candidates < MRG_MAX_NUM_CANDS

  568.     if (s->sh.slice_temporal_mvp_enabled_flag == 0) {

  569.         availableFlagLXCol = 0;

  570.     } else {

  571.         availableFlagL0Col = temporal_luma_motion_vector(s, x0, y0, nPbW, nPbH,

  572.                                                          refIdxL0Col, &mvL0Col, 0);

  573.         // one optimization is that l1 check can be done only when the current slice type is B_SLICE

  574.         if (s->sh.slice_type == B_SLICE) {

  575.             availableFlagL1Col = temporal_luma_motion_vector(s, x0, y0, nPbW,

  576.                                                              nPbH, refIdxL1Col, &mvL1Col, 1);

  577.         }

  578.         availableFlagLXCol = availableFlagL0Col || availableFlagL1Col;

  579.         if (availableFlagLXCol) {

  580.             TMVPCand.is_intra = 0;

  581.             TMVPCand.pred_flag[0] = availableFlagL0Col;

  582.             TMVPCand.pred_flag[1] = availableFlagL1Col;

  583.             if (TMVPCand.pred_flag[0]) {

  584.                 TMVPCand.mv[0] = mvL0Col;

  585.                 TMVPCand.ref_idx[0] = refIdxL0Col;

  586.             }

  587.             if (TMVPCand.pred_flag[1]) {

  588.                 TMVPCand.mv[1] = mvL1Col;

  589.                 TMVPCand.ref_idx[1] = refIdxL1Col;

  590.             }

  591.         }

  592.     }

  593. 

  594.     if (available_a1_flag) {

  595.         mergecandlist[mergearray_index] = spatialCMVS[0];

  596.         mergearray_index++;

  597.     }

  598.     if (available_b1_flag) {

  599.         mergecandlist[mergearray_index] = spatialCMVS[1];

  600.         mergearray_index++;

  601.     }

  602.     if (available_b0_flag) {

  603.         mergecandlist[mergearray_index] = spatialCMVS[2];

  604.         mergearray_index++;

  605.     }

  606.     if (available_a0_flag) {

  607.         mergecandlist[mergearray_index] = spatialCMVS[3];

  608.         mergearray_index++;

  609.     }

  610.     if (available_b2_flag) {

  611.         mergecandlist[mergearray_index] = spatialCMVS[4];

  612.         mergearray_index++;

  613.     }

  614.     if (availableFlagLXCol && mergearray_index < s->sh.max_num_merge_cand) {

  615.         mergecandlist[mergearray_index] = TMVPCand;

  616.         mergearray_index++;

  617.     }

  618.     numMergeCand = mergearray_index;

  619.     numOrigMergeCand = mergearray_index;

  620. 

  621.     // combined bi-predictive merge candidates  (applies for B slices)

  622.     if (s->sh.slice_type == B_SLICE) {

  623.         if (numOrigMergeCand > 1 &&

  624.             numOrigMergeCand < s->sh.max_num_merge_cand) {

  625. 

  626.             combIdx = 0;

  627.             combStop = 0;

  628.             while (combStop != 1) {

  629.                 MvField l0Cand;

  630.                 MvField l1Cand;

  631.                 l0CandIdx = l0_l1_cand_idx[combIdx][0];

  632.                 l1CandIdx = l0_l1_cand_idx[combIdx][1];

  633.                 l0Cand = mergecandlist[l0CandIdx];

  634.                 l1Cand = mergecandlist[l1CandIdx];

  635.                 if (l0Cand.pred_flag[0] == 1 &&

  636.                     l1Cand.pred_flag[1] == 1 &&

  637.                     (refPicList[0].list[l0Cand.ref_idx[0]] !=

  638.                      refPicList[1].list[l1Cand.ref_idx[1]] ||

  639.                      l0Cand.mv[0].x != l1Cand.mv[1].x ||

  640.                      l0Cand.mv[0].y != l1Cand.mv[1].y)) {

  641.                     combCand.ref_idx[0] = l0Cand.ref_idx[0];

  642.                     combCand.ref_idx[1] = l1Cand.ref_idx[1];

  643.                     combCand.pred_flag[0] = 1;

  644.                     combCand.pred_flag[1] = 1;

  645.                     combCand.mv[0].x = l0Cand.mv[0].x;

  646.                     combCand.mv[0].y = l0Cand.mv[0].y;

  647.                     combCand.mv[1].x = l1Cand.mv[1].x;

  648.                     combCand.mv[1].y = l1Cand.mv[1].y;

  649.                     combCand.is_intra = 0;

  650.                     mergecandlist[numMergeCand] = combCand;

  651.                     numMergeCand++;

  652.                 }

  653.                 combIdx++;

  654.                 if (combIdx == numOrigMergeCand * (numOrigMergeCand - 1) ||

  655.                     numMergeCand == s->sh.max_num_merge_cand)

  656.                     combStop = 1;

  657.             }

  658.         }

  659.     }

  660. 

  661.     /*

  662.      * append Zero motion vector candidates

  663.      */

  664.     if (s->sh.slice_type == P_SLICE) {

  665.         numRefIdx = s->sh.nb_refs[0];

  666.     } else if (s->sh.slice_type == B_SLICE) {

  667.         numRefIdx = FFMIN(s->sh.nb_refs[0],

  668.                           s->sh.nb_refs[1]);

  669.     }

  670.     while (numMergeCand < s->sh.max_num_merge_cand) {

  671.         if (s->sh.slice_type == P_SLICE) {

  672.             zerovector.ref_idx[0] = (zeroIdx < numRefIdx) ? zeroIdx : 0;

  673.             zerovector.ref_idx[1] = -1;

  674.             zerovector.pred_flag[0] = 1;

  675.             zerovector.pred_flag[1] = 0;

  676.             zerovector.mv[0].x = 0;

  677.             zerovector.mv[0].y = 0;

  678.             zerovector.mv[1].x = 0;

  679.             zerovector.mv[1].y = 0;

  680.             zerovector.is_intra = 0;

  681.         } else {

  682.             zerovector.ref_idx[0] = (zeroIdx < numRefIdx) ? zeroIdx : 0;

  683.             zerovector.ref_idx[1] = (zeroIdx < numRefIdx) ? zeroIdx : 0;

  684.             zerovector.pred_flag[0] = 1;

  685.             zerovector.pred_flag[1] = 1;

  686.             zerovector.mv[0].x = 0;

  687.             zerovector.mv[0].y = 0;

  688.             zerovector.mv[1].x = 0;

  689.             zerovector.mv[1].y = 0;

  690.             zerovector.is_intra = 0;

  691.         }

  692. 

  693.         mergecandlist[numMergeCand] = zerovector;

  694.         numMergeCand++;

  695.         zeroIdx++;

  696.     }

  697. }

  698. 

  699. /*

  700.  * 8.5.3.1.1 Derivation process of luma Mvs for merge mode

  701.  */

  702. void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0, int nPbW,

  703.                                 int nPbH, int log2_cb_size, int part_idx,

  704.                                 int merge_idx, MvField *mv)

  705. {

  706.     int singleMCLFlag = 0;

  707.     int nCS = 1 << log2_cb_size;

  708.     struct MvField mergecand_list[MRG_MAX_NUM_CANDS] = { { { { 0 } } } };

  709.     int nPbW2 = nPbW;

  710.     int nPbH2 = nPbH;

  711.     HEVCLocalContext *lc = s->HEVClc;

  712. 

  713.     if (s->pps->log2_parallel_merge_level > 2 && nCS == 8) {

  714.         singleMCLFlag = 1;

  715.         x0 = lc->cu.x;

  716.         y0 = lc->cu.y;

  717.         nPbW = nCS;

  718.         nPbH = nCS;

  719.         part_idx = 0;

  720.     }

  721. 

  722.     ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);

  723.     derive_spatial_merge_candidates(s, x0, y0, nPbW, nPbH, log2_cb_size,

  724.                                     singleMCLFlag, part_idx, mergecand_list);

  725. 

  726.     if (mergecand_list[merge_idx].pred_flag[0] == 1 &&

  727.         mergecand_list[merge_idx].pred_flag[1] == 1 &&

  728.         (nPbW2 + nPbH2) == 12) {

  729.         mergecand_list[merge_idx].ref_idx[1] = -1;

  730.         mergecand_list[merge_idx].pred_flag[1] = 0;

  731.     }

  732. 

  733.     *mv = mergecand_list[merge_idx];

  734. }

  735. 

  736. static av_always_inline void dist_scale(HEVCContext *s, Mv * mv,

  737.                                         int pic_width_in_min_pu, int x, int y,

  738.                                         int elist, int ref_idx_curr, int ref_idx)

  739. {

  740.     RefPicList *refPicList = s->ref->refPicList;

  741.     MvField *tab_mvf = s->ref->tab_mvf;

  742.     int ref_pic_elist = refPicList[elist].list[TAB_MVF(x, y).ref_idx[elist]];

  743.     int ref_pic_curr  = refPicList[ref_idx_curr].list[ref_idx];

  744. 

  745.     if (ref_pic_elist != ref_pic_curr)

  746.         mv_scale(mv, mv, s->poc - ref_pic_elist, s->poc - ref_pic_curr);

  747. }

  748. 

  749. static int mv_mp_mode_mx(HEVCContext *s, int x, int y, int pred_flag_index,

  750.                          Mv *mv, int ref_idx_curr, int ref_idx)

  751. {

  752.     MvField *tab_mvf = s->ref->tab_mvf;

  753.     int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size;

  754. 

  755.     RefPicList *refPicList = s->ref->refPicList;

  756. 

  757.     if (TAB_MVF(x, y).pred_flag[pred_flag_index] == 1 &&

  758.         refPicList[pred_flag_index].list[TAB_MVF(x, y).ref_idx[pred_flag_index]] == refPicList[ref_idx_curr].list[ref_idx]) {

  759.         *mv = TAB_MVF(x, y).mv[pred_flag_index];

  760.         return 1;

  761.     }

  762.     return 0;

  763. }

  764. 

  765. 

  766. static int mv_mp_mode_mx_lt(HEVCContext *s, int x, int y, int pred_flag_index,

  767.                             Mv *mv, int ref_idx_curr, int ref_idx)

  768. {

  769.     MvField *tab_mvf = s->ref->tab_mvf;

  770.     int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size;

  771. 

  772.     RefPicList *refPicList = s->ref->refPicList;

  773.     int currIsLongTerm = refPicList[ref_idx_curr].isLongTerm[ref_idx];

  774. 

  775.     int colIsLongTerm =

  776.         refPicList[pred_flag_index].isLongTerm[(TAB_MVF(x, y).ref_idx[pred_flag_index])];

  777. 

  778.     if (TAB_MVF(x, y).pred_flag[pred_flag_index] && colIsLongTerm == currIsLongTerm) {

  779.         *mv = TAB_MVF(x, y).mv[pred_flag_index];

  780.         if (!currIsLongTerm)

  781.             dist_scale(s, mv, pic_width_in_min_pu, x, y, pred_flag_index, ref_idx_curr, ref_idx);

  782.         return 1;

  783.     }

  784.     return 0;

  785. }

  786. 

  787. #define MP_MX(v, pred, mx) \

  788.     mv_mp_mode_mx(s, x##v##_pu, y##v##_pu, pred, &mx, ref_idx_curr, ref_idx)

  789. 

  790. #define MP_MX_LT(v, pred, mx) \

  791.     mv_mp_mode_mx_lt(s, x##v##_pu, y##v##_pu, pred, &mx, ref_idx_curr, ref_idx)

  792. 

  793. void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,

  794.                               int nPbH, int log2_cb_size, int part_idx,

  795.                               int merge_idx, MvField *mv,

  796.                               int mvp_lx_flag, int LX)

  797. {

  798.     HEVCLocalContext *lc = s->HEVClc;

  799.     MvField *tab_mvf = s->ref->tab_mvf;

  800.     int isScaledFlag_L0 = 0;

  801.     int availableFlagLXA0 = 0;

  802.     int availableFlagLXB0 = 0;

  803.     int availableFlagLXCol = 0;

  804.     int numMVPCandLX = 0;

  805.     int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size;

  806. 

  807.     int xA0, yA0;

  808.     int xA0_pu, yA0_pu;

  809.     int is_available_a0;

  810. 

  811.     int xA1, yA1;

  812.     int xA1_pu, yA1_pu;

  813.     int is_available_a1;

  814. 

  815.     int xB0, yB0;

  816.     int xB0_pu, yB0_pu;

  817.     int is_available_b0;

  818. 

  819.     int xB1, yB1;

  820.     int xB1_pu = 0, yB1_pu = 0;

  821.     int is_available_b1 = 0;

  822. 

  823.     int xB2, yB2;

  824.     int xB2_pu = 0, yB2_pu = 0;

  825.     int is_available_b2 = 0;

  826.     Mv mvpcand_list[2] = { { 0 } };

  827.     Mv mxA = { 0 };

  828.     Mv mxB = { 0 };

  829.     Mv mvLXCol = { 0 };

  830.     int ref_idx_curr = 0;

  831.     int ref_idx = 0;

  832.     int pred_flag_index_l0;

  833.     int pred_flag_index_l1;

  834.     int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);

  835.     int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);

  836. 

  837.     int cand_up = (lc->ctb_up_flag || y0b);

  838.     int cand_left = (lc->ctb_left_flag || x0b);

  839.     int cand_up_left =

  840.             (!x0b && !y0b) ? lc->ctb_up_left_flag : cand_left && cand_up;

  841.     int cand_up_right =

  842.             (x0b + nPbW == (1 << s->sps->log2_ctb_size) ||

  843.              x0  + nPbW >= lc->end_of_tiles_x) ? lc->ctb_up_right_flag && !y0b

  844.                                                : cand_up;

  845.     int cand_bottom_left = (y0 + nPbH >= lc->end_of_tiles_y) ? 0 : cand_left;

  846. 

  847.     ref_idx_curr       = LX;

  848.     ref_idx            = mv->ref_idx[LX];

  849.     pred_flag_index_l0 = LX;

  850.     pred_flag_index_l1 = !LX;

  851. 

  852.     // left bottom spatial candidate

  853.     xA0 = x0 - 1;

  854.     yA0 = y0 + nPbH;

  855.     xA0_pu = xA0 >> s->sps->log2_min_pu_size;

  856.     yA0_pu = yA0 >> s->sps->log2_min_pu_size;

  857. 

  858.     is_available_a0 = PRED_BLOCK_AVAILABLE(A0) && AVAILABLE(cand_bottom_left, A0);

  859. 

  860.     //left spatial merge candidate

  861.     xA1 = x0 - 1;

  862.     yA1 = y0 + nPbH - 1;

  863.     xA1_pu = xA1 >> s->sps->log2_min_pu_size;

  864.     yA1_pu = yA1 >> s->sps->log2_min_pu_size;

  865. 

  866.     is_available_a1 = AVAILABLE(cand_left, A1);

  867.     if (is_available_a0 || is_available_a1) {

  868.         isScaledFlag_L0 = 1;

  869.     }

  870. 

  871.     if (is_available_a0) {

  872.         availableFlagLXA0 = MP_MX(A0, pred_flag_index_l0, mxA);

  873.         if (!availableFlagLXA0)

  874.             availableFlagLXA0 = MP_MX(A0, pred_flag_index_l1, mxA);

  875.     }

  876. 

  877.     if (is_available_a1 && !availableFlagLXA0) {

  878.         availableFlagLXA0 = MP_MX(A1, pred_flag_index_l0, mxA);

  879.         if (!availableFlagLXA0)

  880.             availableFlagLXA0 = MP_MX(A1, pred_flag_index_l1, mxA);

  881.     }

  882. 

  883.     if (is_available_a0 && !availableFlagLXA0) {

  884.         availableFlagLXA0 = MP_MX_LT(A0, pred_flag_index_l0, mxA);

  885.         if (!availableFlagLXA0)

  886.             availableFlagLXA0 = MP_MX_LT(A0, pred_flag_index_l1, mxA);

  887.     }

  888. 

  889.     if (is_available_a1 && !availableFlagLXA0) {

  890.         availableFlagLXA0 = MP_MX_LT(A1, pred_flag_index_l0, mxA);

  891.         if (!availableFlagLXA0)

  892.             availableFlagLXA0 = MP_MX_LT(A1, pred_flag_index_l1, mxA);

  893.     }

  894. 

  895.     // B candidates

  896.     // above right spatial merge candidate

  897.     xB0 = x0 + nPbW;

  898.     yB0 = y0 - 1;

  899.     xB0_pu = xB0 >> s->sps->log2_min_pu_size;

  900.     yB0_pu = yB0 >> s->sps->log2_min_pu_size;

  901. 

  902.     is_available_b0 = PRED_BLOCK_AVAILABLE(B0) && AVAILABLE(cand_up_right, B0);

  903. 

  904.     if (is_available_b0) {

  905.         availableFlagLXB0 = MP_MX(B0, pred_flag_index_l0, mxB);

  906.         if (!availableFlagLXB0)

  907.             availableFlagLXB0 = MP_MX(B0, pred_flag_index_l1, mxB);

  908.     }

  909. 

  910.     if (!availableFlagLXB0) {

  911.         // above spatial merge candidate

  912.         xB1 = x0 + nPbW - 1;

  913.         yB1 = y0 - 1;

  914.         xB1_pu = xB1 >> s->sps->log2_min_pu_size;

  915.         yB1_pu = yB1 >> s->sps->log2_min_pu_size;

  916. 

  917.         is_available_b1 = AVAILABLE(cand_up, B1);

  918. 

  919.         if (is_available_b1) {

  920.             availableFlagLXB0 = MP_MX(B1, pred_flag_index_l0, mxB);

  921.             if (!availableFlagLXB0)

  922.                 availableFlagLXB0 = MP_MX(B1, pred_flag_index_l1, mxB);

  923.         }

  924.     }

  925. 

  926.     if (!availableFlagLXB0) {

  927.         // above left spatial merge candidate

  928.         xB2 = x0 - 1;

  929.         yB2 = y0 - 1;

  930.         xB2_pu = xB2 >> s->sps->log2_min_pu_size;

  931.         yB2_pu = yB2 >> s->sps->log2_min_pu_size;

  932.         is_available_b2 = AVAILABLE(cand_up_left, B2);

  933. 

  934.         if (is_available_b2) {

  935.             availableFlagLXB0 = MP_MX(B2, pred_flag_index_l0, mxB);

  936.             if (!availableFlagLXB0)

  937.                 availableFlagLXB0 = MP_MX(B2, pred_flag_index_l1, mxB);

  938.         }

  939.     }

  940. 

  941.     if (isScaledFlag_L0 == 0) {

  942.         if (availableFlagLXB0) {

  943.             availableFlagLXA0 = 1;

  944.             mxA = mxB;

  945.         }

  946.         availableFlagLXB0 = 0;

  947. 

  948.         // XB0 and L1

  949.         if (is_available_b0) {

  950.             availableFlagLXB0 = MP_MX_LT(B0, pred_flag_index_l0, mxB);

  951.             if (!availableFlagLXB0)

  952.                 availableFlagLXB0 = MP_MX_LT(B0, pred_flag_index_l1, mxB);

  953.         }

  954. 

  955.         if (is_available_b1 && !availableFlagLXB0) {

  956.             availableFlagLXB0 = MP_MX_LT(B1, pred_flag_index_l0, mxB);

  957.             if (!availableFlagLXB0)

  958.                 availableFlagLXB0 = MP_MX_LT(B1, pred_flag_index_l1, mxB);

  959.         }

  960. 

  961.         if (is_available_b2 && !availableFlagLXB0) {

  962.             availableFlagLXB0 = MP_MX_LT(B2, pred_flag_index_l0, mxB);

  963.             if (!availableFlagLXB0)

  964.                 availableFlagLXB0 = MP_MX_LT(B2, pred_flag_index_l1, mxB);

  965.         }

  966.     }

  967. 

  968.     if (availableFlagLXA0 && availableFlagLXB0 &&

  969.         (mxA.x != mxB.x || mxA.y != mxB.y)) {

  970.         availableFlagLXCol = 0;

  971.     } else {

  972.         //temporal motion vector prediction candidate

  973.         if (s->sh.slice_temporal_mvp_enabled_flag == 0) {

  974.             availableFlagLXCol = 0;

  975.         } else {

  976.             availableFlagLXCol = temporal_luma_motion_vector(s, x0, y0, nPbW,

  977.                     nPbH, ref_idx, &mvLXCol, LX);

  978.         }

  979.     }

  980. 

  981.     if (availableFlagLXA0) {

  982.         mvpcand_list[numMVPCandLX] = mxA;

  983.         numMVPCandLX++;

  984.     }

  985.     if (availableFlagLXB0) {

  986.         mvpcand_list[numMVPCandLX] = mxB;

  987.         numMVPCandLX++;

  988.     }

  989. 

  990.     if (availableFlagLXA0 && availableFlagLXB0 &&

  991.         mxA.x == mxB.x && mxA.y == mxB.y) {

  992.         numMVPCandLX--;

  993.     }

  994. 

  995.     if (availableFlagLXCol && numMVPCandLX < 2) {

  996.         mvpcand_list[numMVPCandLX] = mvLXCol;

  997.         numMVPCandLX++;

  998.     }

  999. 

  1000.     while (numMVPCandLX < 2) { // insert zero motion vectors when the number of available candidates are less than 2

  1001.         mvpcand_list[numMVPCandLX].x = 0;

  1002.         mvpcand_list[numMVPCandLX].y = 0;

  1003.         numMVPCandLX++;

  1004.     }

  1005. 

  1006.     mv->mv[LX].x = mvpcand_list[mvp_lx_flag].x;

  1007.     mv->mv[LX].y = mvpcand_list[mvp_lx_flag].y;

  1008. }