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.
57171 Commits
32 Branches
333MB
Tree: cf49d0156d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cf49d0156d'
${ noResults }
FFmpeg/libavcodec/hevc_mvs.c

1008 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.     ff_thread_await_progress(&ref->tf, INT_MAX, 0);

  276.     if (tab_mvf &&

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

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

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

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

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

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

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

  284.         temp_col = TAB_MVF_PU(PRb);

  285.         availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(PRb);

  286.     } else {

  287.         mvLXCol->x = 0;

  288.         mvLXCol->y = 0;

  289.         availableFlagLXCol = 0;

  290.     }

  291. 

  292.     // derive center collocated motion vector

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

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

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

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

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

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

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

  300.         temp_col = TAB_MVF_PU(PCtr);

  301.         availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(PCtr);

  302.     }

  303.     return availableFlagLXCol;

  304. }

  305. 

  306. #define AVAILABLE(cand, v) \

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

  308. 

  309. #define PRED_BLOCK_AVAILABLE(v) \

  310.     check_prediction_block_available(s, log2_cb_size, \

  311.                                      x0, y0, nPbW, nPbH, \

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

  313. 

  314. #define COMPARE_MV_REFIDX(a, b) \

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

  316. 

  317. /*

  318.  * 8.5.3.1.2  Derivation process for spatial merging candidates

  319.  */

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

  321.                                             int nPbW, int nPbH, int log2_cb_size,

  322.                                             int singleMCLFlag, int part_idx,

  323.                                             struct MvField mergecandlist[])

  324. {

  325.     HEVCLocalContext *lc = &s->HEVClc;

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

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

  328. 

  329.     int available_a1_flag = 0;

  330.     int available_b1_flag = 0;

  331.     int available_b0_flag = 0;

  332.     int available_a0_flag = 0;

  333.     int available_b2_flag = 0;

  334.     struct MvField spatialCMVS[MRG_MAX_NUM_CANDS];

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

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

  337.     struct Mv mvL0Col = { 0 };

  338.     struct Mv mvL1Col = { 0 };

  339. 

  340.     //first left spatial merge candidate

  341.     int xA1 = x0 - 1;

  342.     int yA1 = y0 + nPbH - 1;

  343.     int is_available_a1;

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

  345. 

  346.     int check_MER = 1;

  347.     int check_MER_1 = 1;

  348. 

  349.     int xB1, yB1;

  350.     int is_available_b1;

  351.     int xB1_pu;

  352.     int yB1_pu;

  353. 

  354.     int check_B0;

  355.     int xB0, yB0;

  356.     int isAvailableB0;

  357.     int xB0_pu;

  358.     int yB0_pu;

  359. 

  360.     int check_A0;

  361.     int xA0, yA0;

  362.     int is_available_a0;

  363.     int xA0_pu;

  364.     int yA0_pu;

  365. 

  366.     int xB2, yB2;

  367.     int isAvailableB2;

  368.     int xB2_pu;

  369.     int yB2_pu;

  370.     int mergearray_index = 0;

  371. 

  372.     struct MvField zerovector;

  373.     int numRefIdx = 0;

  374.     int zeroIdx = 0;

  375. 

  376.     int numMergeCand = 0;

  377.     int numOrigMergeCand = 0;

  378.     int sumcandidates = 0;

  379.     int combIdx = 0;

  380.     int combStop = 0;

  381.     int l0CandIdx = 0;

  382.     int l1CandIdx = 0;

  383. 

  384.     int refIdxL0Col = 0;

  385.     int refIdxL1Col = 0;

  386.     int availableFlagLXCol = 0;

  387. 

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

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

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

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

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

  393. 

  394. 

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

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

  397. 

  398.     int availableFlagL0Col = 0;

  399.     int availableFlagL1Col = 0;

  400. 

  401.     is_available_a1 = AVAILABLE(cand_left, A1);

  402. 

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

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

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

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

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

  408.         is_available_a1 = 0;

  409.     }

  410. 

  411.     if (is_available_a1) {

  412.         available_a1_flag = 1;

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

  414.     } else {

  415.         available_a1_flag = 0;

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

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

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

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

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

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

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

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

  424.         spatialCMVS[0].is_intra = 0;

  425.     }

  426. 

  427.     // above spatial merge candidate

  428. 

  429.     xB1 = x0 + nPbW - 1;

  430.     yB1 = y0 - 1;

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

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

  433. 

  434.     is_available_b1 = AVAILABLE(cand_up, B1);

  435. 

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

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

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

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

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

  441.         is_available_b1 = 0;

  442.     }

  443. 

  444.     if (is_available_a1 && is_available_b1)

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

  446. 

  447.     if (is_available_b1 && check_MER) {

  448.         available_b1_flag = 1;

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

  450.     } else {

  451.         available_b1_flag = 0;

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

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

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

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

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

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

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

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

  460.         spatialCMVS[1].is_intra = 0;

  461.     }

  462. 

  463.     // above right spatial merge candidate

  464.     xB0 = x0 + nPbW;

  465.     yB0 = y0 - 1;

  466.     check_MER = 1;

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

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

  469.     check_B0 = PRED_BLOCK_AVAILABLE(B0);

  470. 

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

  472. 

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

  474.         isAvailableB0 = 0;

  475. 

  476.     if (is_available_b1 && isAvailableB0)

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

  478. 

  479.     if (isAvailableB0 && check_MER) {

  480.         available_b0_flag = 1;

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

  482.     } else {

  483.         available_b0_flag = 0;

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

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

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

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

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

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

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

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

  492.         spatialCMVS[2].is_intra = 0;

  493.     }

  494. 

  495.     // left bottom spatial merge candidate

  496.     xA0 = x0 - 1;

  497.     yA0 = y0 + nPbH;

  498.     check_MER = 1;

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

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

  501.     check_A0 = PRED_BLOCK_AVAILABLE(A0);

  502. 

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

  504. 

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

  506.         is_available_a0 = 0;

  507. 

  508.     if (is_available_a1 && is_available_a0)

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

  510. 

  511.     if (is_available_a0 && check_MER) {

  512.         available_a0_flag = 1;

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

  514.     } else {

  515.         available_a0_flag = 0;

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

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

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

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

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

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

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

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

  524.         spatialCMVS[3].is_intra = 0;

  525.     }

  526. 

  527.     // above left spatial merge candidate

  528.     xB2 = x0 - 1;

  529.     yB2 = y0 - 1;

  530.     check_MER = 1;

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

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

  533. 

  534.     isAvailableB2 = AVAILABLE(cand_up_left, B2);

  535. 

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

  537.         isAvailableB2 = 0;

  538. 

  539.     if (is_available_a1 && isAvailableB2)

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

  541. 

  542.     if (is_available_b1 && isAvailableB2)

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

  544. 

  545.     sumcandidates = available_a1_flag + available_b1_flag + available_b0_flag

  546.             + available_a0_flag;

  547. 

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

  549.         available_b2_flag = 1;

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

  551.     } else {

  552.         available_b2_flag = 0;

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

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

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

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

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

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

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

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

  561.         spatialCMVS[4].is_intra = 0;

  562.     }

  563. 

  564.     // temporal motion vector candidate

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

  566.     // available candidates < MRG_MAX_NUM_CANDS

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

  568.         availableFlagLXCol = 0;

  569.     } else {

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

  571.                                                          refIdxL0Col, &mvL0Col, 0);

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

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

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

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

  576.         }

  577.         availableFlagLXCol = availableFlagL0Col || availableFlagL1Col;

  578.         if (availableFlagLXCol) {

  579.             TMVPCand.is_intra = 0;

  580.             TMVPCand.pred_flag[0] = availableFlagL0Col;

  581.             TMVPCand.pred_flag[1] = availableFlagL1Col;

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

  583.                 TMVPCand.mv[0] = mvL0Col;

  584.                 TMVPCand.ref_idx[0] = refIdxL0Col;

  585.             }

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

  587.                 TMVPCand.mv[1] = mvL1Col;

  588.                 TMVPCand.ref_idx[1] = refIdxL1Col;

  589.             }

  590.         }

  591.     }

  592. 

  593.     if (available_a1_flag) {

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

  595.         mergearray_index++;

  596.     }

  597.     if (available_b1_flag) {

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

  599.         mergearray_index++;

  600.     }

  601.     if (available_b0_flag) {

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

  603.         mergearray_index++;

  604.     }

  605.     if (available_a0_flag) {

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

  607.         mergearray_index++;

  608.     }

  609.     if (available_b2_flag) {

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

  611.         mergearray_index++;

  612.     }

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

  614.         mergecandlist[mergearray_index] = TMVPCand;

  615.         mergearray_index++;

  616.     }

  617.     numMergeCand = mergearray_index;

  618.     numOrigMergeCand = mergearray_index;

  619. 

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

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

  622.         if (numOrigMergeCand > 1 &&

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

  624. 

  625.             combIdx = 0;

  626.             combStop = 0;

  627.             while (combStop != 1) {

  628.                 MvField l0Cand;

  629.                 MvField l1Cand;

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

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

  632.                 l0Cand = mergecandlist[l0CandIdx];

  633.                 l1Cand = mergecandlist[l1CandIdx];

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

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

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

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

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

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

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

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

  642.                     combCand.pred_flag[0] = 1;

  643.                     combCand.pred_flag[1] = 1;

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

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

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

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

  648.                     combCand.is_intra = 0;

  649.                     mergecandlist[numMergeCand] = combCand;

  650.                     numMergeCand++;

  651.                 }

  652.                 combIdx++;

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

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

  655.                     combStop = 1;

  656.             }

  657.         }

  658.     }

  659. 

  660.     /*

  661.      * append Zero motion vector candidates

  662.      */

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

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

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

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

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

  668.     }

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

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

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

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

  673.             zerovector.pred_flag[0] = 1;

  674.             zerovector.pred_flag[1] = 0;

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

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

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

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

  679.             zerovector.is_intra = 0;

  680.         } else {

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

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

  683.             zerovector.pred_flag[0] = 1;

  684.             zerovector.pred_flag[1] = 1;

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

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

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

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

  689.             zerovector.is_intra = 0;

  690.         }

  691. 

  692.         mergecandlist[numMergeCand] = zerovector;

  693.         numMergeCand++;

  694.         zeroIdx++;

  695.     }

  696. }

  697. 

  698. /*

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

  700.  */

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

  702.                                 int nPbH, int log2_cb_size, int part_idx,

  703.                                 int merge_idx, MvField *mv)

  704. {

  705.     int singleMCLFlag = 0;

  706.     int nCS = 1 << log2_cb_size;

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

  708.     int nPbW2 = nPbW;

  709.     int nPbH2 = nPbH;

  710.     HEVCLocalContext *lc = &s->HEVClc;

  711. 

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

  713.         singleMCLFlag = 1;

  714.         x0 = lc->cu.x;

  715.         y0 = lc->cu.y;

  716.         nPbW = nCS;

  717.         nPbH = nCS;

  718.         part_idx = 0;

  719.     }

  720. 

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

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

  723.                                     singleMCLFlag, part_idx, mergecand_list);

  724. 

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

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

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

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

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

  730.     }

  731. 

  732.     *mv = mergecand_list[merge_idx];

  733. }

  734. 

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

  736.                                         int pic_width_in_min_pu, int x, int y,

  737.                                         int elist, int ref_idx_curr, int ref_idx)

  738. {

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

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

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

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

  743. 

  744.     if (ref_pic_elist != ref_pic_curr)

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

  746. }

  747. 

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

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

  750. {

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

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

  753. 

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

  755. 

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

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

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

  759.         return 1;

  760.     }

  761.     return 0;

  762. }

  763. 

  764. 

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

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

  767. {

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

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

  770. 

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

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

  773. 

  774.     int colIsLongTerm =

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

  776. 

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

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

  779.         if (!currIsLongTerm)

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

  781.         return 1;

  782.     }

  783.     return 0;

  784. }

  785. 

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

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

  788. 

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

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

  791. 

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

  793.                               int nPbH, int log2_cb_size, int part_idx,

  794.                               int merge_idx, MvField *mv,

  795.                               int mvp_lx_flag, int LX)

  796. {

  797.     HEVCLocalContext *lc = &s->HEVClc;

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

  799.     int isScaledFlag_L0 = 0;

  800.     int availableFlagLXA0 = 0;

  801.     int availableFlagLXB0 = 0;

  802.     int availableFlagLXCol = 0;

  803.     int numMVPCandLX = 0;

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

  805. 

  806.     int xA0, yA0;

  807.     int xA0_pu, yA0_pu;

  808.     int is_available_a0;

  809. 

  810.     int xA1, yA1;

  811.     int xA1_pu, yA1_pu;

  812.     int is_available_a1;

  813. 

  814.     int xB0, yB0;

  815.     int xB0_pu, yB0_pu;

  816.     int is_available_b0;

  817. 

  818.     int xB1, yB1;

  819.     int xB1_pu = 0, yB1_pu = 0;

  820.     int is_available_b1 = 0;

  821. 

  822.     int xB2, yB2;

  823.     int xB2_pu = 0, yB2_pu = 0;

  824.     int is_available_b2 = 0;

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

  826.     Mv mxA = { 0 };

  827.     Mv mxB = { 0 };

  828.     Mv mvLXCol = { 0 };

  829.     int ref_idx_curr = 0;

  830.     int ref_idx = 0;

  831.     int pred_flag_index_l0;

  832.     int pred_flag_index_l1;

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

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

  835. 

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

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

  838.     int cand_up_left =

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

  840.     int cand_up_right =

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

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

  843.                                                : cand_up;

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

  845. 

  846.     ref_idx_curr       = LX;

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

  848.     pred_flag_index_l0 = LX;

  849.     pred_flag_index_l1 = !LX;

  850. 

  851.     // left bottom spatial candidate

  852.     xA0 = x0 - 1;

  853.     yA0 = y0 + nPbH;

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

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

  856. 

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

  858. 

  859.     //left spatial merge candidate

  860.     xA1 = x0 - 1;

  861.     yA1 = y0 + nPbH - 1;

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

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

  864. 

  865.     is_available_a1 = AVAILABLE(cand_left, A1);

  866.     if (is_available_a0 || is_available_a1) {

  867.         isScaledFlag_L0 = 1;

  868.     }

  869. 

  870.     if (is_available_a0) {

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

  872.         if (!availableFlagLXA0)

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

  874.     }

  875. 

  876.     if (is_available_a1 && !availableFlagLXA0) {

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

  878.         if (!availableFlagLXA0)

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

  880.     }

  881. 

  882.     if (is_available_a0 && !availableFlagLXA0) {

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

  884.         if (!availableFlagLXA0)

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

  886.     }

  887. 

  888.     if (is_available_a1 && !availableFlagLXA0) {

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

  890.         if (!availableFlagLXA0)

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

  892.     }

  893. 

  894.     // B candidates

  895.     // above right spatial merge candidate

  896.     xB0 = x0 + nPbW;

  897.     yB0 = y0 - 1;

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

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

  900. 

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

  902. 

  903.     if (is_available_b0) {

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

  905.         if (!availableFlagLXB0)

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

  907.     }

  908. 

  909.     if (!availableFlagLXB0) {

  910.         // above spatial merge candidate

  911.         xB1 = x0 + nPbW - 1;

  912.         yB1 = y0 - 1;

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

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

  915. 

  916.         is_available_b1 = AVAILABLE(cand_up, B1);

  917. 

  918.         if (is_available_b1) {

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

  920.             if (!availableFlagLXB0)

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

  922.         }

  923.     }

  924. 

  925.     if (!availableFlagLXB0) {

  926.         // above left spatial merge candidate

  927.         xB2 = x0 - 1;

  928.         yB2 = y0 - 1;

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

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

  931.         is_available_b2 = AVAILABLE(cand_up_left, B2);

  932. 

  933.         if (is_available_b2) {

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

  935.             if (!availableFlagLXB0)

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

  937.         }

  938.     }

  939. 

  940.     if (isScaledFlag_L0 == 0) {

  941.         if (availableFlagLXB0) {

  942.             availableFlagLXA0 = 1;

  943.             mxA = mxB;

  944.         }

  945.         availableFlagLXB0 = 0;

  946. 

  947.         // XB0 and L1

  948.         if (is_available_b0) {

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

  950.             if (!availableFlagLXB0)

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

  952.         }

  953. 

  954.         if (is_available_b1 && !availableFlagLXB0) {

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

  956.             if (!availableFlagLXB0)

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

  958.         }

  959. 

  960.         if (is_available_b2 && !availableFlagLXB0) {

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

  962.             if (!availableFlagLXB0)

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

  964.         }

  965.     }

  966. 

  967.     if (availableFlagLXA0 && availableFlagLXB0 &&

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

  969.         availableFlagLXCol = 0;

  970.     } else {

  971.         //temporal motion vector prediction candidate

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

  973.             availableFlagLXCol = 0;

  974.         } else {

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

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

  977.         }

  978.     }

  979. 

  980.     if (availableFlagLXA0) {

  981.         mvpcand_list[numMVPCandLX] = mxA;

  982.         numMVPCandLX++;

  983.     }

  984.     if (availableFlagLXB0) {

  985.         mvpcand_list[numMVPCandLX] = mxB;

  986.         numMVPCandLX++;

  987.     }

  988. 

  989.     if (availableFlagLXA0 && availableFlagLXB0 &&

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

  991.         numMVPCandLX--;

  992.     }

  993. 

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

  995.         mvpcand_list[numMVPCandLX] = mvLXCol;

  996.         numMVPCandLX++;

  997.     }

  998. 

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

  1000.         mvpcand_list[numMVPCandLX].x = 0;

  1001.         mvpcand_list[numMVPCandLX].y = 0;

  1002.         numMVPCandLX++;

  1003.     }

  1004. 

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

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

  1007. }