Inter-coding prediction tools in video coding

Abstract

Methods and systems are described for video coding and decoding using inter-coding prediction tools. Two sets of methods are proposed for overlapped block-motion compensation (OBMC): a) methods to reduce computational complexity with minimal impact on compression efficiency and b) methods to increase compression efficiency, but potentially at an increased computational cost.

Description

INTER-CODING PREDICTION TOOLS IN VIDEO CODINGCROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This patent application claims the benefit of priority from Indian Provisional Patent Application Ser. No.202411037828, filed on May 14, 2024, and Indian Provisional Patent Application Ser. No.202411095111, filed on December 3, 2024, each of which is incorporated by reference herein in its entirety.TECHNOLOGY

[0002] The present document relates generally to images and video coding. More particularly, an embodiment of the present invention relates to inter-coding prediction tools in video coding.BACKGROUND

[0003] In 2020, the MPEG group in the International Standardization Organization (ISO), jointly with the International Telecommunications Union (ITU), released the first version of the Versatile Video Coding Standard (VVC), also known as H.266 (Ref. [1]). More recently, the same group has been working on the development of the next generation coding standard that provides improved coding performance over existing video coding technologies. As part of this investigation, new coding techniques are also examined.

[0004] As appreciated by the inventors here, improved techniques for applying interceding prediction tools in image and video coding are desired, and they are described herein. As used herein, the term inter-coding refers to coding a picture by using as reference other pictures in the same video sequence to take advantage of temporal redundancies among neighboring pictures.

[0005] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section. Similarly, issues identified with respect to one or more approaches should not assume to have been recognized in any prior art on the basis of this section, unless otherwise indicated.BRIEF DESCRIPTION OF THE DRAWINGS

[0006] An embodiment of the present invention is illustrated by way of example, and not in way by limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:

[0007] FIG. 1A depicts an example workflow of a two-stage overlapped block-motion compensation (OBMC) process;

[0008] FIG. IB depicts an example workflow of the OBMC CU boundary flow in FIG. 1A;

[0009] FIG. 1C depicts an example workflow of the OBMC SubCU boundary flow in FIG. 1A;

[0010] FIG. ID depicts example OBMC neighbor blocks at the CU or SubCU level for N-tap motion compensation;

[0011] FIG. 2 depicts an example of OBMC SubCU boundary flow according to an embodiment of this invention;

[0012] FIG. 3 depicts an example of an OBMC workflow for decoder-side motion vector refinement (DMVR) CUs according to an embodiment of this invention;

[0013] FIG. 4A depicts an example of unified OBMC flow according to an embodiment of this invention;

[0014] FIG. 4B depicts an example of unified workflow for OBMC blending according to an embodiment of this invention;

[0015] FIG. 5 A depicts an example of overlap blending of reference samples (OBRS) in OBMC according to an embodiment of this invention, when no realignment of neighbor samples is needed;

[0016] FIG. 5B depicts an example of overlap blending of reference samples (OBRS) in OBMC according to an embodiment of this invention, when realignment of neighbor samples is needed; and

[0017] FIG. 5C depicts an example process of OBRS in OBMC according to an embodiment of this invention.

[0018] FIG. 6A and FIG. 6B depict an example process of OBMC according to an embodiment where the number of motion compensation computations with neighbor MVs for each subblock is restricted to a maximum value.

[0019] FIG. 7A depicts an example hardware implementation according to an embodiment without OBMC hardware optimization; and

[0020] FIG. 7B depicts an example hardware implementation according to an embodiment with OBMC hardware optimization.DESCRIPTION OF EXAMPLE EMBODIMENTS

[0021] Example embodiments that relate to applying inter-coding prediction tools in video coding are described herein. In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the various embodiments of present invention. It will be apparent, however, that the various embodiments of the present invention may be practiced without these specific details. In other instances, well-known structures and devices are not described in exhaustive detail, in order to avoid unnecessarily occluding, obscuring, or obfuscating embodiments of the present invention.SUMMARY

[0022] Example embodiments described herein relate to applying inter-coding prediction tools in image and video coding, especially when applying overlapped block-motion compensation (OBMC). Some of the proposed embodiments may reduce computational complexity with minimal impact on compression efficiency, while other embodiments may increase compression efficiency, but potentially with an increased computational cost. Example embodiments include methods to:• reduce the number of operations related to motion compensation in OBMC• improve the weights being used in motion compensation in OBMC, thus improving coding efficiency• incorporate additional neighbors in OBMC• take advantage of computation in decoder- side motion vector refinement (DMVR) to reduce complexity in OBMC• improve sub-pel motion compensation in OBMC; and• reduce memory bandwidth and hardware complexity.INTER-CODING PREDICTION IN VIDEO CODINGOverlapped Block Motion Compensation (OBMC)

[0023] In the enhanced compression model (ECM) software implementation, e.g., ECM 10 or later (Ref. [2]), OBMC improves coding efficiency by overlapping inter prediction resulting from different motion information at block boundaries of a coding unit (CU) and sub-block boundaries (subCUs) within a CU (e.g., see FIG. ID). OBMC involves a distance based weighted sum (blending) of inter prediction data derived from a current block’ s and neighbor blocks’ motion (when it is different from current motion) to derive the final prediction. The sub-block size used for OBMC is 4x4.

[0024] When OBMC is applied, top and left boundary pixels of a CU are refined using a neighboring block’s motion information with a weighted prediction as described in Ref. [3].

[0025] Currently, the conditions for not applying OBMC are as follows:• When OBMC is disabled at the Sequence Parameter Set (SPS) level• When the current block has intra mode or intra-block copy (IBC) mode• When the current luma block size is smaller or equal to 32Additionally, OBMC is adaptively controlled on a block level as follows:• The OBMC flag is inherited from a neighboring affine block for affine merge mode.• OBMC is not applied to a block if there is a neighbor block coded with IBC, palette, or Block Differential Pulse Code Modulation (BDPCM) modes.• When applying OBMC to a block, a block boundary check whether OBMC is applied to the boundary is further made based on the reference samples of the current block. If any absolute difference between the prediction sample and non-interpolated (integer pel) reference sample is greater than a threshold, the OBMC is not applied to that boundary.

[0026] A subblock-boundary OBMC is performed by applying the same blending to the top, left, bottom, and right subblock boundary pixels using neighboring subblocks’ motion information. It is enabled for the subblock based coding tools:• Affine Advanced Motion Vector Prediction (AMVP) modes;• Affine merge modes and subblock-based temporal motion vector prediction(SbTMVP);• Subblock-based bilateral matching.

[0027] When OBMC mode is used in Combined Inter and Intra Prediction (CIIP) mode with Luma mapping and chroma scaling (LMCS), inter blending is performed prior to LMCS mapping of inter samples. LMCS is applied to blended inter samples which are combined with LMCS applied intra samples in CIIP mode,where InterpredYrepresents the samples predicted by the motion of current block in the original domain, IntrapredYrepresents the samples predicted in the mapped domain, OBMCpredYrepresents the samples predicted by the motion of neighboring blocks in the original domain, and w0and w are the weights.

[0028] When OBMC mode is used in a Local Illumination Compensation (LIC) coded block, the LIC parameters are applied to generate the corresponding prediction samples for the OBMC of the LIC coded block. Besides, to reduce the complexity, the OBMC is only applied to the top and left CU boundaries while being always disabled for the boundaries of the internal sub-blocks of the LIC coded block.

[0029] FIG. 1A illustrates a two-stage workflow (100) for OBMC as applied in ECM. The first stage (105) is identified as the boundary stage where only top and left neighbors are blended. The second stage (110) is identified as a SubCU stage where all the subblocks are parsed and all four neighbors are considered. FIG. IB depicts an example workflow of the OBMC CU boundary flow (115) in process 100, and FIG. 1C depicts an example workflow of the OBMC SubCU boundary flow (120) in process 100. FIG. ID depicts example OBMC neighbor blocks at the CU or Subblock CU level for N-tap motion compensation (e.g., N = 12).Blending process at every 4x4 subblock

[0030] Assume a Weight Matrix, WM[4] = {wtO, wtl, wt2, wt3] (for example, {27, 16, 6, 0} for luma and {27, 0, 0, 0} for chroma) / * for each pixel in a 4x4 subblock* / x =0 to 3 y = 0 to 3 w0= WM[y], w = WM[x], w2= IVM[3 — x] , w3= IVM[3 — y];sumW = w0+ w + w2+ w3(3)OBMC Improvements

[0031] Embodiments presented herein cover three main parts. The first part focuses on reducing OBMC complexity, the second part focuses on improving OBMC coding efficiency, and the third part focuses on reducing hardware complexity and memory bandwidth.OBMC complexity reduction

[0032] Two example embodiments for reducing complexity are presented next. Simulation results show that when combining the two methods, one can maintain 90% of the coding gain using OBMC, but with more than 50% decoding time reduction of OBMC in ECM.Disable pixel level early exit check at CU boundary.

[0033] In current ECM, at the CU boundary, motion compensation (MC) is calculated using neighbor motion and compared at the pixel level against current prediction under JVET_AD0193_ADAPTIVE_OBMC_CONTROL (Ref.[4]). For example, Ref.[4] states: “If any absolute difference between the prediction sample and non-interpolated (integer pel) reference sample is greater than a threshold, then OBMC is not applied to that boundary. It is proposed to disable pixel-level comparison and instead do a single comparison at the CU level, e.g., by computing the sum of absolute differences (SAD) (or any other suitable distance metric) between the current CU and a neighbor and skipping OBMC if the SAD is larger than a threshold. Experimental results show that there is almost no loss while computational complexity is reduced.Decisions to enable / disable Motion Compensation (MC)

[0034] Consider a current 4x4 sub-block, surrounded by eight 4x4 sub-blocks: top left, top, top right, left, right, bottom left, bottom, and bottom right (e.g., see FIG. ID).SubCU minimum threshold criterion for motion vector distance (MVD)

[0035] It was observed that if the MVD between a sub-block among the neighboring subblocks and the current sub-block is less than a threshold, then the contribution to the gain of applying OBMC is negligible, if any, and the corresponding neighbor MC call can be skipped or disabled. FIG. 2, depicts an example embodiment for this method. In more details: i. Given a neighbor (nbr), motion vector distance (MVD) is calculated between the current sub-block (cur) and the neighbor motion vectors. This is separately computed for each L0 and LI direction.1. mvdLO = curMvLO - nbrMvLO2. mvdLl = curMvLl - nbrMvLl ii. Compute1. distLO = absfmvdLO. x) + absfmvdLO. y)2. distLl = absfmvdLl. x) + abs (mvdLl. y) (4) if Biprediction (Bi), nbrMvDist = distLO + distLl else (if uniprediction (Uni)) nbrMvDist = distLX, where dislLXX distLO or distL , and abs(d) denotes the absolute value |a|. iii. Disable the neighbor MC call when nbrMvDist < Th where Th is a threshold. For example, without limitation, in one embodiment, Th = 12 (for Uni) or 24 (for Bi), while, in another embodiment, Th = 6 (for Uni) or 12 (for Bi). iv. The threshold is not applied at the CU boundary.Alternatively, in other embodiments, the following modifications can be applied.1. To ensure vertical and horizontal components of MVD are within the limits to disable neighbor MC, OBMC is disabled if:where LX = L or / J , and one needs to consider both L and LI in bidirectional mode.2. An OBMC early exit condition can be based on a sum of absolute differences (SAD) between motion compensated data of the current MV and the neighbor MV. That is: if(SAD < Th\ || SAD > 77 / 2), then disable the OBMC blending process with that neighbor, where, for example, Th\ can be 32 for a 4x4 sub-block (2 per sub-block pixel sample) and Th! can be 128 (8 per sub-block pixel sample).

[0036] Note that this last method has no dependency on the sum of abs(mvdLX.x) and abs(mvdLX.y) and difference of abs(mvdLX.x) and abs(mvdLX.y) solution.

[0037] It is noted that different distance metrics than SAD can be used, such as Euclidian distance instead of Manhattan distance.Disable Chroma OBMC

[0038] In an embodiment, chroma OBMC may be disabled, which reduces the computation complexity of chroma MC using neighboring MVs and the subsequent blending process for chroma components under certain conditions. In an embodiment, chroma OBMC for the current coding unit is disabled for all inter CUs. In another embodiment, chroma OBMC for the current coding unit is disabled for only Merge CUs. Under current practice, in certain Inter CUs like Inter Cross component prediction (CCP) CUs, chroma is predicted from luma which is already reconstructed using the OBMC process, hence OBMC for chroma component of Inter CCP CUs may be skipped.Restrict OBMC subblock to Uni Pred CUs

[0039] To reduce decoding complexity, under certain conditions, it is proposed to disable OBMC for bipredicted subblocks. In one embodiment, the condition can be: disable OBMC for the current CU if CurrSubPu. interDir = Bi.This helps reduce MC complexity by half at the subblock level.

[0040] When the CurrSubPu.interDir != Bi and if (neighSubPu.interDir == Uni), i.e., neighSubPu is either LO or LI unidirectional, then compute unidirectional MC and apply OBMC blending. If (neighSubPu. interDir == Bi), ignore neighSubPu for MC and blending.

[0041] In another embodiment, when the CurrSubPu.interDir != Bi and if (neighSubPu. interDir == Bi), compute unidirectional MC (LO or LI - refer to current subblock) and blend.Neighbor MC Selection

[0042] Motion properties between the current sub-block and a neighbor sub-block can be checked to identify neighbors with identical motion property and are not considered for blending (thus eliminating a MC call).

[0043] It is proposed that only neighbors that differ in motion properties are selected for OBMC. The motion properties are described using the following:1. Inter Direction2. RefldxO or Refldxl3. MVO or MVlMethod 3: Variable Tap MC for OBMC neighbor MCs only.

[0044] In ECM 11, 12-tap motion compensation interpolation filters are being used for 4x4 neighbor motion compensation (MC), which adds complexity and memory access. It is proposed to replace the 12-tap filter with a filter with fewer taps, such as an 8-tap filter (like the one being used in HEVC).OBMC coding efficiency improvementsMethod 1: MVD Min and Max Threshold

[0045] In an embodiment, one may apply a threshold on MVDs to avoid MC computations and blending of two different objects using a derived min and max threshold.This can be applied at the CU boundary or at sub-CU level. The threshold can be CU-size adaptive. The details are similar to those described earlier (e.g., the data flow in FIG. 2).Method 2: Implicit derivation of obmcFlag for Inter CUs

[0046] In current implementations, the value of flag obmcFlag (denoting whether OBMC is to be applied for the current coding unit) is derived as follows: if (!cu.cs->sps->getUseOBMC() || CU::isIBC(cu) || cu.predMode == MODE INTRA || cu.lwidth() * cu.lheight() < 32) obmcFlag = false else if cu.firstPU->mergeFlag obmcFlag = true else obmcFlag is signalled in the bitstream on the encoding side and parsed on the decoding side to decide whether OBMC to be applied for the current CU or not.In simple terms, if obmcFlag = true, then apply OBMC for the current coding unit otherwise do not apply the OBMC for the current CU.

[0047] In an embodiment, it is proposed to implicitly derive “obmcFlag” to reduce signaling overhead for Inter (non-merge mode is the inter CU mode where motion vector difference (MVD) is coded in the bitstream, whereas merge mode of inter CU doesn’t code any MVD in the bitstream). For example, in an embodiment, the obmcFlag may be set implicitly to “True” for all Inter CUs with or without CU size restriction.For example, in an embodiment with CU size restriction, the obmcFlag is defined as: if (!cu.cs->sps->getUseOBMC() || CU::isIBC(cu) || cu.predMode == MODE INTRA || cu.lwidth() * cu.lheight() < 32) obmcFlag = false else obmcFlag = trueAlternatively, in an embodiment without CU size restriction:if (!cu.cs->sps->getUseOBMC() || CU::isIBC(cu) || cu.predMode == MODE INTRA ) obmcFlag = false else obmcFlag = trueImprovement in coding efficiency is expected as the obmcFlag is not signaled in the bitstream for non-merge mode of Inter CUs, which saves additional bits.Method 3 : Blending Weights improvement.

[0048] In an embodiment it is proposed to change the blending weights and number of lines being blended. It is proposed that weights are changed such that they represent blending as per motion field variations over the 4x4 sub-block. Weights can be adaptively derived using motion or texture difference between the current and neighbor subblocks. In an embodiment, OBMC blending weights are adaptively derived based on motion vector difference or based on SAD between MC using current MVs and Neighbor MVs or both. For example, blending weights can be adaptively derived as follows: a. Based on MVD associated with the neighbor i. Compute sum of absolute MVDs1. distLO = abs(mvdL0. x) + absfmvdLO. y)2. distLl = abs(mvdLl. x) + absfmvdLl. y) z / Biprediction (Bi), nbrMvDist = distLO + distLl else (if uniprediction (Uni)) nbrMvDist = distLX ii. If ( nbrMvDist > Th), i.e., current sub-block motion property is different from neighbor motion property, then reduce weights for neighbor MV based MC during blending process. Note that Nbr Weights + Cur Weights = 1 in floating point. iii. For example, Th can be 128 (for uni -predict! on) and 256 (for Biprediction).Adaptive Nbr Weights = (Fixed Nbr Weights * Th) / nbrMvDist. b. Compute SAD using current MC and neighbor MC and then compute adaptive blending weights.i. if(SAD > Th), i.e., current sub-block texture property is different from neighbor texture property. Note that Nbr Weights + Cur Weights = 1 in floating point. ii. For example, Th can be 128 (8 per sample).Adaptive Nbr Weights = (Fixed Nbr Weights * Th) / SAD.Method 4: Disable CU-Size Restriction

[0049] In an embodiment, it is allowed to perform OBMC for CU sizes less or equal to 32, e.g., 4x4, 4x8, and 8x4.Method 5. Add diagonal neighbor.

[0050] In an embodiment, additional Top-Left, Top-Right, Bottom-Left and Bottom- Right neighbors may be used in OBMC blending. This would require a new set of diagonally- aligned blending weights. One may apply the current fixed weights for 3 lines or develop new weights.Method 6: Use SAD from top and left neighbor.

[0051] While iteratively applying OBMC to all subblocks and using SAD of MC data from current MV and neighbor MV to decide to enable / disable OBMC for the given subblock boundary, use the same condition for that sub-block boundary when neighbor becomes current and current becomes neighbor. This will reduce computational complexity.Method 7: Modify how Geometric Partition Mode (GPM) works with OBMC.

[0052] If GPM is inter / inter and if GPM partition boundary intersects neighbor boundary, the neighbor MC (non-geometric) is likely not suited for blending with a geometric subblock. Hence it is proposed to disable OBMC in such case. In addition, Bi-prediction is only predicting the same object.Method 8: improve OBMC when CU is Decoder-side Motion Vector Refinement (DMVR) refined.

[0053] As depicted in FIG. 3, in an embodiment, one may reuse the bilinear interpolation MC data for neighbor MV-based motion compensated data for OBMC blending from the DMVR bilinear interpolation process. By this method, additional MC-complexity and memory bandwidth increase for OBMC is avoided. This simplified OBMC for DMVR can also help reduce the visual artifacts on SubCU boundaries on DMVR CUs.

[0054] As explained in Ref. [2], during Decoder-side Motion Vector Refinement (DMVR) a refined motion vector is searched around the two initial MVs in the reference picture lists L0 and LI. The refined MVs (MV0_passl and MVl_passl) are derived around the initial MVs based on the minimum bilateral matching cost between the two reference blocks in L0 and LI.

[0055] As depicted in FIG. 3, in step 305, one applies bilinear motion compensation to get the refined area for DMVR using the initial MVs and a refinement area. For example, if the current block initial merge MVs are [MV0(x,y) and MVl(x,y)] and the refinement area is + / - R (on both x and y directions), then one gets the motion compensated reference samples of size (R + BlockWidth + R + 4) x (R + BlockHeight + R + 4) centered around MV0 and MV1 using a bilinear interpolation filter. The additional 4 samples are to accommodate the reference region for the right- most and bottom- most 4x4 OBMC subblocks. Note that the OBMC subblock blending process is not changed in this approach, only 4x4 internal subblocks alone reuse the Bilinear MC from DMVR. Note that the refined motion vector information (307) is also passed to block 320.

[0056] Next, in step 310, one applies the DMVR refinement process using bilateral matching (see Ref.[2]). In step 315, one derives the best refined MVs. Finally, during the OBMC blending process (step 320), one may apply OBMC blending for DMVR CUs using the current inter prediction data at 4x4 level and Bilinear motion compensation using the neighbour refined MVs (from DMVR) for internal 4x4 subblocks only. By reusing the bilinear motion compensation from DMVR one avoids the additional 12-tap motion compensation filtering required using neighbor MVs.Hardware complexity considerations for OBMCMethod 1 : Harmonize OBMC blending process across CU Boundary and Sub-Cu Boundary.

[0057] As depicted in FIG. 4A and FIG. 4B, in an embodiment, the blending process across the top CU boundary sub-blocks, the left CU boundary sub-blocks and the interior sub-blocks is unified. This unified design helps to simplify the hardware implementation by not having different logical steps and reduces the sequential processing dependency and overall processing latency.

[0058] In essence, process 100 is now replaced by process 400, and workflows 115 and 120 are now replaced by workflow 410. Note that the early exit condition of FIG. 2 is still applicable, that is, test 415 can be replaced by test 215.Method 2: Restrict the number of neighbors subblocks considered for OBMC blending to a specific value.

[0059] In OBMC, considering four neighbors from top, left, bottom and right, the worstcase number of additional motion compensation computations required for each subblock is four for uni-prediction and eight for bi-prediction. As depicted in FIG. 6A, using process (600) (which replaces process 410), the number of neighbors subblocks considered for additional motion compensation and OBMC blending may be reduced to a specific value, denoted as Max_count (e.g., Max_count = 1 or 2). The value of Max_count may be determined based on trade-offs between coding efficiency and hardware (HW) complexity. The proposed process 600 helps to reduce the overall processing latency of the HW design, chip area and memory bandwidth requirements by reducing the number of additional motion compensation computations required.

[0060] To better explain the impact of the proposed algorithm to hardware design, consider the high-level hardware implementations depicted in FIG. 7A and FIG. 7B. As depicted in FIG. 7A, given processor 720, memory 710, and a memory interface 712, during OBMC, motion compensation (MC) requires accessing data from reference frames for five stages: for the four neighbor blocks and the current block. In an embodiment, as depicted in FIG. 7B, given a selection of a single neighbor block (e.g., Max_count = 1), the transfer requests between processor 730 and memory 710 are reduced to only two: for the current block and the selected neighbor block. Overall, the memory transfers of reference data from external memory (where reference frames are stored) to internal memory (on-chip memory)may be reduced from 5 to 2%, where x denotes data to be transferred to perform MC for one block. These figures also show that the number of processing blocks required to perform motion compensation are also reduced, which will directly reduce hardware complexity and internal memory requirements.

[0061] As depicted in FIG. 6B, the selection process of neighbor sub-block MVs to be used for the blending process is decided based on motion information, such as interprediction direction (unidirectional or bidirectional) (step 625), reference indices of the motion vectors (step 630), and the sum of absolute motion vector references (step 635). Note that reference indices (which when they are equal for two blocks indicate that the two blocks are predicted from the same reference picture) are compared only when the inter direction (Uni / Bi) is the same for all neighbor subblocks. MVs are compared only when inter direction and reference direction are the same for all neighbor subblocks.

[0062] As depicted in FIG. 6A, in process 600, for a subblock under consideration:• In step 602, motion information from all four neighbor subblocks is extracted (e.g., 4 MVs for uni-prediction and 8 MVs for bi-prediction).• Next, in step 605, given a Max_count value, an array of Max_count best neighbor subblocks is selected using the processing steps in FIG. 6B (605), with functionality as depicted via steps 620-645, which, in step 645, will return an array with the best Max_count neighbor subblocks. Given the selected best neighbor subblocks, the process will: a) (610) perform or get the motion compensation of the current sub-block using the current subblock MV and an M-tap filter and using the motion vectors of the best neighbor subblocks using an N-Tap filter, and b) (615) perform the blending process, and then return to the parent function to traverse subsequent subblocks.As an example, without limitation, in one embodiment, M = 12-tap DCTIF filter and N = 8-tap DCTIF filter. In another embodiment, M = N = 8-tap DCTIF filter.

[0063] As depicted in FIG. 6B, given Max_count, in an embodiment, the array of best neighbor subblocks may be selected as follows:In step 620, based on availability, access the inter direction (Bi or Uni), reference indices, and MVs of neighbor sub-blocks in the order of top, left, bottom and right.Set threshold Th (e.g., Th = 12 per direction, considering 1 / 16 pel MV accuracy), idx = 0, where threshold Th assists to avoid the blocks which are very similar in motion, and idx tracks the number of best neighbor subblocks found in an array, say Best_neigh_subblock[] .• In step 625, for each subblock in all 4 directions (but within the Max_count constraint): if the inter direction of the current block and the neighbor block is different, then add the neighbor subblock to Best_neigh_subblock[idx], idx++, go to step 645 if idx equal to Max_count.• In step 630, for each subblock in all 4 directions which is not in Best_neigh_subblock[] (but within the Max_count constraint): if the reference index of the current and neighbor subblocks is different, then add the neighbor subblock to Best_neigh_subblock[], idx++, go to step 645 if idx equal to Max_count.• In step 635, if the number of identified best neighbors is still smaller than Max_count, then the best neighbors are determined using sums of absolute motion vector differences and threshold Th. More specifically: o Sort all the neighbor blocks, say M, that are not part of Best_neigh_subblock[] in neigh_subblock_sorted[], in descending order based on the sum of absolute MV differences. Let absMvd_sorted[k] denote the sum of absolute MV differences corresponding to the neigh_subblock_sorted[k], for k = 0, 1,.. M- 1. o Then, for the j-th element in neigh_subblock_sorted[], if absMvd_sorted[j] > Th, then Best_neigh_subblock[idx] = neigh_subblock_sorted[j] , idx++, go to step 645 if idx equal to Max_count, else repeat for next value in neigh_subblock_sorted[] .See equation (4) for an example on how the sum of absolute differences may be computed.

[0064] In summary, the selection process of the best (Max_count) neighbor subblocks is performed according to the following priorities:• the current subblock and its neighbors have different inter direction• the current subblock and its neighbors have different reference indices• the sum of absolute differences of MVs in the current subblock and its neighbors is greater than a thresholdFollowing the proposed priority, instead of arbitrarily dropping candidate neighbor subblocks, allows for reduced complexity with minimal impact to coding efficiency.

[0065] In an embodiment, using pseudocode, process 605 may be described as follows:Initialization: access inter-direction, reference indices, and MVs of neighboring sub-locks. Set Max_count, Th, idx = 0; while (idx < Max_count) { for each neighbor subblock: compare inter direction between current subblock and neighbor subblock; if different, add the neighbor to Best_neigh_subblock[] and increment idx;} while idx < Max_count) { for each neighbor subblock that is not part of Best_neigh_subblock[]: compare the reference index between the current subblock and the neighbor subblock; if different, add the neighbor to Best_neigh_subblock[] and increment idx;} if (idx < Max_count) { sort all M neighbor subblocks that are not part of Best_neigh_subblock[] in a list (say, neigh_subblock_sorted[]) in descending order based on sum of absolute MV differences between the current subblock and the neighbor subblock; let absMvd_sorted[fc] be the sum of absolute MV differences corresponding to neigh_subblock_sorted[fc], wherein k = 0, 1, ..., M-l; while (idx < Max_count) { for j = 0, 1, ..., M-l, for the j-th neighbor subblock in neigh_subblock_sorted[] : if absMvd_sorted[ / ] > Th;Best_neigh_subblock[zri ] = neigh_subblock_sorted[ / ], and increment idx;}}•OBMC based on Overlap Blending of Reference Samples (OBRS)

[0066] This section describes a method to reduce OBMC complexity by blending the reference samples of the current MV and the neighbor MVs prior to MC filtering (e.g., during sub-pixel interpolation). In the current ECM -based OBMC prediction, the neighbor MV- based 12-tap sub-pel MC prediction is blended with the current MV-based 12-tap sub-pel MC prediction. This increases significantly the overall OBMC complexity. Using bilinear interpolation for neighbor MV sub-pel prediction, one can reduce OBMC complexity but one also loses the accuracy offered by a 12-tap or 8-tap MC interpolation filter.

[0067] In an embodiment, OBMC MC complexity can be reduced by first blending the reference samples in the integer sample locations of the current MV and the neighbor MVs prior to sub-pel motion compensation. Sub-pel interpolation is then performed on the blended reference samples using the regular 12-tap MC interpolation filter in ECM. This method eliminates the need for multiple sub-pel interpolations of neighbor MV and the current MVs.

[0068] A simplified example of this approach is provided in FIG. 5A. For simplicity, the sub-pixel locations of the current and neighbor MVs are assumed to be the same. As depicted in FIG. 5A, given current MV reference samples (Xc) and neighbor MV reference samples (Xn), and sub-pixel locations indicated by “O”, a new set of overlap blended reference samples (Xo) are generated prion to motion compensation (MC). Note that neighbor MV reference samples (Xn) are fetched and blended with current MV reference samples (Xc) only at the corresponding CU boundaries and sub-CU boundaries based on the OMBC width (w’), the OBMC height (h’) and the MC interpolation filter-tap (Ntap or N) (e.g., see FIG. ID). That is,Xo(i,j) = blend(Xn(i,j), Xc(i,j)).

[0069] After blending, a regular 12-tap (or 8-tap) interpolation filter for sub-pixel motion compensation is used to derive the final overlapped block inter prediction samples.

[0070] FIG. 5B depicts the OBRS steps when the sub-pel positions of current MV and neighbor MV are not aligned. In this case, the neighbor MV reference samples (Xn) arerealigned using bilinear interpolation based on the sub-pel difference of the neighbor and current motion vectors as follows, and also depicted in FIG. 5C:1. (Step 520) For a given forward or backward direction, LX, (LX = L0 or LI), derive the difference of sub-pixel locations of the neighbor MV, nbrMVLX, and current MV, curMVLX, as follows: nbrSubpelx = fractionl_pel nbrMVLX. x) nbrSubpely = fractionl_pel(nbrMVLX. y) curSubpelx = fractionl_pel curMVLX. x) curSubpely = fractionl_pel(curMVLX. y)For instance, the above equations for a sub-pel precision of 1 / 16-sample units translate to: nbrSubpelx = nbrMVLX. x & 15 nbrSubpely = nbrMVLX.y & 15 curSubpelx = cur MV LX. x & 15 curSubpely = curMVLX.y & 15SubpelDeltax = nbrSubpelx — curSubpelx SubpelDeltay = nbrSubpely — curSubpely where “&” denotes a bit-wise “and” operation.2. Based on the difference of sub-pel locations (SubpelDeltax, SubpelDeltay'), as shown in FIG. 5B and FIG. 5C, realign (505) the neighbor MV reference samples (Xn) using bilinear interpolation to generate X’n samples as:X’n = BilinearInterpolate(Xn, SubpelDeltax, SubpelDeltay) , where, for example and without limitation, 2-tap bilinear interpolation of integer spaced reference samples Xn(i,j) at sub-pel location (SubpelDeltax, SubpelDeltay) and sub-pel precision of 1 / 16-sample unit can be derived as:+ Wii * xni + l,j + 1) / SubpelDeltax\ / SubpelDeltay\ woo=( \1 7176 / ) * ( \ 1 7176 / )Notel: If SubpelDeltax is negative, then the column starting from the left of the original reference samples (Xn) column is used for bilinear interpolation. Similarly, if SubpelDeltay is negative, then the row starting from the top of the original reference samples (Xn) is used for bilinear interpolation. If SubpelDeltax and SubpelDeltay are positive (or zero), the original reference samples (Xn) are used for bilinear interpolation without any row or column shift.Note2: Neighbor MV reference samples (Xn) are fetched and blended with current MV reference samples (Xc) only at the corresponding CU boundaries and sub-CU boundaries based on the OMBC width (w’), the OBMC height (h’) and the MC interpolation filter-tap (N or Ntap) (e.g., see FIG. ID).3. Blend the aligned neighbor reference samples with the current reference samples using existing OBMC weights to generate the overlap blended reference samples Xo(i,j) = blend(X’n(i,j), Xc(i,j)), as shown in the blending step (510) of FIG. 5B and FIG. 5C.Note: In the case of subblock OBMC, the overlap blending of reference samples (OB RS) process in steps 1 to 2 is done for each neighbor of a current subblock. In step 525, the proposed subblock OBRS neighbor reference sample realignment is applied to the left (1), top (t), right (r) and bottom (b) neighbors followed by parallel blending in step 3 to derive blended reference samples Xo(i,j)Xo(i,j) = blend(XT(i,j), X’t(i,j), X’r(i,j), X’b(i,j), Xc(i,j)).This blending method is the same as in equation (3). However, given that OBRS blends the neighbor and current reference samples prior to applying the final MC interpolation, the effective influence of the neighbor reference samples on the final interpolated samples is lower than the original OBMC process for a given setof blending weights wO, wl, w2, and w3. As specified earlier, example ECM blending weights include {27, 16, 6, 0} for luma and {27, 0, 0, 0} for chroma. It is therefore proposed to increase the blending weights wO, wl, w2, w3 for OBRS by a scale factor of S with and additional offset of O. For example, the modified OBRS luma and chroma blending weights for scale and offset factors of S = 1.25 and 0 = 2 would be {36, 22, 10, 2} and {36, 2, 2, 2} respectively.4. (Step 530) Apply regular 12-tap (or 8-tap) motion compensation interpolation using the blended reference samples to derive the inter-prediction samples of the current block.

[0071] The main advantage of OBRS based OBMC is the reduced complexity of MC interpolation and MC bandwidth. This method replaces multiple 12-tap MC interpolation steps of neighboring subblocks in ECM based OBMC with low complexity bilinear interpolation of neighbor reference samples. The overlap blending of realigned reference samples followed by single 12-tap MC interpolation process at the end indirectly enables higher order MC interpolation for all the reference samples.ReferencesEach one of the references listed herein is incorporated by reference in its entirety. The term JVET refers to the Joint Video Experts Team of ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29.[1] “Versatile Video Coding,” Rec. ITU-T H.266, August 2020.[2] JVET-AG2025, “Algorithm description of Enhanced Compression Model 12 (ECM 12),” M. Coban et al., JVET output document, 33d meeting, by teleconference, Jan. 2024.[3] JVET-L0101, “CE10.2.1: OBMC,” Z-Y. Lin et al., 12thmeeting, Macao, CN, Oct. 2018.[4] JVET-AD0193, “EE2-2.11e: Adaptive OBMC control,” K. Cui et al., 30thmeeting, Antalya, TR, April 2023.EXAMPLE COMPUTER SYSTEM IMPLEMENTATION

[0072] Embodiments of the present invention may be implemented with a computer system, systems configured in electronic circuitry and components, an integrated circuit (IC) device such as a microcontroller, a field programmable gate array (FPGA), or anotherconfigurable or programmable logic device (PLD), a discrete time or digital signal processor (DSP), an application specific IC (ASIC), and / or apparatus that includes one or more of such systems, devices or components. The computer and / or IC may perform, control, or execute instructions relating to applying inter-coding prediction tools in image and video coding, such as those described herein. The computer and / or IC may compute any of a variety of parameters or values that relate to applying inter-coding prediction tools in image and video coding described herein. The image and video embodiments may be implemented in hardware, software, firmware and various combinations thereof.

[0073] Certain implementations of the invention comprise computer processors which execute software instructions which cause the processors to perform a method of the invention. For example, one or more processors in a display, an encoder, a set top box, a transcoder, or the like may implement methods related to applying inter-coding prediction tools in image and video coding as described above by executing software instructions in a program memory accessible to the processors. Embodiments of the invention may also be provided in the form of a program product. The program product may comprise any non- transitory and tangible medium which carries a set of computer-readable signals comprising instructions which, when executed by a data processor, cause the data processor to execute a method of the invention. Program products according to the invention may be in any of a wide variety of non-transitory and tangible forms. The program product may comprise, for example, physical media such as magnetic data storage media including floppy diskettes, hard disk drives, optical data storage media including CD ROMs, DVDs, electronic data storage media including ROMs, flash RAM, or the like. The computer-readable signals on the program product may optionally be compressed or encrypted.

[0074] Where a component (e.g. a software module, processor, assembly, device, circuit, etc.) is referred to above, unless otherwise indicated, reference to that component (including a reference to a "means") should be interpreted as including as equivalents of that component any component which performs the function of the described component (e.g., that is functionally equivalent), including components which are not structurally equivalent to the disclosed structure which performs the function in the illustrated example embodiments of the invention.EQUIVALENTS, EXTENSIONS, ALTERNATIVES AND MISCELLANEOUS

[0075] Example embodiments that relate to applying inter-coding prediction coding tools in image and video coding are thus described. In the foregoing specification, embodiments ofthe present invention have been described with reference to numerous specific details that may vary from implementation to implementation. Thus, the sole and exclusive indicator of what is the invention, and what is intended by the applicants to be the invention, is the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction. Any definitions expressly set forth herein for terms contained in such claims shall govern the meaning of such terms as used in the claims. Hence, no limitation, element, property, feature, advantage or attribute that is not expressly recited in a claim should limit the scope of such claim in any way. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.

[0076] Various aspects of the present disclosure may be appreciated from the following Enumerated Example Embodiments (EEEs):What is claimed is:EEE 1. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for a subblock (SubCU) in the current CU with a neighborSubCU: generating motion vector distance values: mvdLO = curMvL - nbrMvLO, and mvdLl = curMvLl - nbrMvLl,' generating distance values: distLO = abs(mvdL0. x) + abs(mvdL0. y and distLl = abs(mvdLl. x) + abs( nvdLl. yy, generating a neighbor moving distance value nbrMvDist, wherein nbrMvDist = distLO + distLl in biprediction mode and nbrMvDist = distLX, in uniprediction mode, where A = 0 or 1; and disabling computing motion compensation for the neighbor SubCU if nbrMvDist < Th, wherein Th is a threshold, curMvLO and curMvLl denote motion vectors for the current CU, and nbrMvL and nbrMvLl denote motion vectors for the neighbor CU.EEE 2. The method of EEE 1, wherein the neighbor SubCU is a top neighbor SubCU or a left neighbor SubCU.EEE 3. The method of EEE 1 or EEE 2, wherein Th = 0 for a subblock (SubCU) at the boundary of the current CU, else Th = 12 for the uni-prediction mode and Th = 24 for the biprediction mode.EEE 4. The method of any one of EEEs 1-3, wherein disabling computing motion compensation for the neighbor SubCU occurs if(abs(mvdLX. x) < T / i / 2) && abs(mvdLX.y)) < T / i / 2), wherein LX is LO or L 1.EEE 5. The method of any one of EEEs 1-4, wherein computing motion compensation for the neighbor SubCU is always allowed, but OBMC blending is disabled if (SAD < Th || SAD > Th2 wherein Th\ and Th! are thresholds and SAD denotes a distance metric between motion compensated data extracted using the current motion vector (curMvLX) and the neighbor motion vector (nbrMvLX).EEE 6. The method of any one of EEEs 1-5, further comprising disabling OBMC for all bipredicted current subblocks.EEE 7. The method of EEE 6, further comprising: if the current subblock is not a bi-predicted subblock, then if the neighbor subblock is a bi-predicted subblock then skip motion compensation (MC) and blending for the neighbor subblock, else compute unidirectional MC and apply OBMC blending.EEE 8. The method of EEE 6, further comprising: if the current subblock is not a bi-predicted subblock, then if the neighbor subblock is a bi-predicted subblock then compute only unidirectional compensation (MC) and blending for the neighbor subblock.EEE 9. The method of any one of EEEs 1-8, wherein if nbrMvDist > Th2, then, computing adaptive neighbor blending weights asAdaptive Nbr Weights = (Fixed Nbr Weights * Th2 nbrMvDist,Current subblock weights = 1 - Adaptive Nbr Weights, wherein ‘Fixed Nbr Weights' denotes fixed neighbor blending weights for OBMC, and Th2 is a second threshold.EEE 10. The method of EEE 9, wherein Th2 = 128 for a uni-predicted subblock and Th2 = 256 for a bi-predicted subblock.EEE 11. The method of any one of EEEs 1-10, wherein if computing MC for the neighbor subblock is allowed, then computing a distance metric (SAD) between motion compensated data extracted using the current motion vector (curMvLX') and the neighbor motion vector (nbrMvLX), and if(SAD > Th2), thenAdaptive Nbr Weights = (Fixed Nbr Weights * Th2)l SAD,Current subblock weights = 1 - Adaptive Nbr Weights, wherein Fixed Nbr Weights' denotes fixed neighbor blending weights for OBMC, and Th2 is a second threshold.EEE 12. A method for video decoding, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and always applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, provided the current CU is not predicted in intra mode or intra-block copy (IBC) mode.EEE 13. The method of EEE 12, wherein OBMC is not restricted for current CU sizes less than 32, including 4x4, 4x8, or 8x14.EEE 14. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for an internal subblock (SubCU) in the current CU: generating motion compensated reference samples based on Decoder-side Motion Vector Refinement (DMVR) and bilinear motion compensation;applying OBMC by reusing the motion compensated reference samples generated from the DMVR motion compensation.EEE 15. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: generating current MV reference samples (Xc) and neighbor MV reference samples (Xn); and if OBMC is enabled, then: generating samples Xo by applying OBMC blending weights to the Xc and Xn samples; and applying motion-compensation interpolation filtering to the Xo samples.EEE 16. The method of EEE 15, wherein generating sub-pixel samples Xo further comprises: for a given forward or backward direction, LX, (LX = LO or LI), deriving differences of sub-pixel locations of a neighbor MV (nbrMVLX), and a current MV (curMVLX) as:SubpelDeltax = nbrSubpelx — curSubpelx,SubpelDeltay = nbrSubpely — curSubpely, whereingenerating the realigned neighbor MV reference samples (X’n) based on the neighbor MV reference samples (Xn), SubpelDeltax, and SubpelDeltay, blending the realigned MV neighbor reference samples with the current reference samples using existing OBMC weights to generate the overlap-blended reference samples Xo; andapplying sub-pixel motion compensation interpolation using the overlap-blended reference samples to derive the inter-prediction samples of the current block.EEE 17. The method of EEE 16, wherein the realigned neighbor MV reference samples (X’n) are generating using bilinear interpolation.EEE 18. The method of EEE 16, wherein for a subblock CU of the current CU the blending is performed for a left, top, right, and neighbor subblock CU to the subblock CU.EEE 19. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for a subblock (SubCU) in the current CU with one or more neighbor SubCUs: accessing motion-vector (MV) related information from the SubCU and the one or more neighbor SubCUs, including inter-direction, reference index information, and MV values; creating a list of Max_count best neighbor SubCUs (Best_neigh_subblock[]) using a hierarchical decision process that is based on the inter direction information, the reference index information, and motion- vector difference information between motion vectors of the SubCU and its neighbor SubCUs; and performing OBMC using only the Max_count best neighbor SubCUs.EEE 20. The method of EEE 19, wherein Max_count = 1.EEE 21. The method of EEE 19, wherein Max_count is at least 1 but smaller than 4.EEE 22. The method of EEE 19, wherein the hierarchical decision process examines neighbor SubCUs using a top, left, bottom, and right sequence order.EEE 23. The method of EEE 19, wherein the hierarchical decision process comprises: set idx = 0; while (idx < Max_count) { for each neighbor SubCU: compare inter direction between the SubCU and the neighbor SubCU;if different, add the neighbor SubCU to Best_neigh_subblock[] and increment idx;} while (idx < Max_count) { for each neighbor SubCU that is not part of Best_neigh_subblock[]: compare the reference index between the SubCU and the neighbor SubCU; if different, add the neighbor to Best_neigh_subblock[] and increment idx;} if idx < Max_count) { sort all M neighbor SubCUs that are not part of Best_neigh_subblock[] in a list (neigh_subblock_sorted[]) in descending order based on sum of absolute MV differences between the SubCU and the neighbor SubCU; let absMvd_sorted[fc] be the sum of absolute MV differences corresponding to neigh_subblock_sorted[fc], wherein k = 0, 1, ..., M-l; while (idx < Max_count) { for a j-th neighbor SubCU in neigh_subblock_sorted[] : if absMvd_sorted[ / ] > Th, where Th denotes a threshold;Best_neigh_subblock[z ] = neigh_subblock_sorted[ / ] and increment idx;}}•EEE 24. A tangible computer-readable storage medium having stored thereon computerexecutable instructions for executing with one or more processors a method in accordance with any one of the methods recited in EEEs 1-23.EEE 25. An apparatus comprising a processor and configured to perform any one of the methods recited in EEEs 1-23.

Claims

CLAIMSWhat is claimed is:

1. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for a subblock (SubCU) in the current CU with a neighbor SubCU: generating motion vector distance values: mvdLO = curMvLO - nbrMvLO, and mvdLl = curMvLl - nbrMvLl,' generating distance values: distLO = abs(mvdL0. x) + abs(mvdLO. y and distLl = abs(mvdLl. x) + abs( nvdLl. yy, generating a neighbor moving distance value nbrMvDist, wherein nbrMvDist = distLO + distLl in biprediction mode and nbrMvDist = distLX, in uniprediction mode, where A = 0 or 1; and disabling computing motion compensation for the neighbor SubCU if nbrMvDist < Th, wherein Th is a threshold, curMvLO and curMvLl denote motion vectors for the current CU, and nbrMvL and nbrMvLl denote motion vectors for the neighbor CU.

2. The method of claim 1, wherein the neighbor SubCU is a top neighbor SubCU or a left neighbor SubCU.

3. The method of claim 1 or claim 2, wherein Th = 0 for a subblock (SubCU) at the boundary of the current CU, else Th = 12 for the uni-prediction mode and Th = 24 for the biprediction mode.

4. The method of any one of claims 1-3, wherein disabling computing motion compensation for the neighbor SubCU occurs if(abs(mvdLX. x) < T / i / 2) && abs(mvdLX.y)) < T / i / 2), wherein Z is L0 or L 1.

5. The method of any one of claims 1-4, wherein computing motion compensation for the neighbor SubCU is always allowed, but OBMC blending is disabled if (SAD < Th || SAD > Th2 wherein Th\ and Th! are thresholds and SAD denotes a distance metric between motion compensated data extracted using the current motion vector (curMvLX) and the neighbor motion vector (nbrMvLX).

6. The method of any one of claims 1-5, further comprising disabling OBMC for all bipredicted current subblocks.

7. The method of claim 6, further comprising: if the current subblock is not a bi-predicted subblock, then if the neighbor subblock is a bi-predicted subblock then skip motion compensation (MC) and blending for the neighbor subblock, else compute unidirectional MC and apply OBMC blending.

8. The method of claim 6, further comprising: if the current subblock is not a bi-predicted subblock, then if the neighbor subblock is a bi-predicted subblock then compute only unidirectional compensation (MC) and blending for the neighbor subblock.

9. The method of any one of claims 1-8, wherein if nbrMvDist > Th2, then, computing adaptive neighbor blending weights asAdaptive Nbr Weights = (Fixed Nbr Weights * Th2)l nbrMvDist,Current subblock weights = 1 - Adaptive Nbr Weights, wherein ‘Fixed Nbr Weights' denotes fixed neighbor blending weights for OBMC, and Th2 is a second threshold.

10. The method of claim 9, wherein Th2 = 128 for a uni-predicted subblock and Th2 = 256 for a bi-predicted subblock.

11. The method of any one of claims 1-10, wherein if computing MC for the neighbor subblock is allowed, thencomputing a distance metric (SAD) between motion compensated data extracted using the current motion vector (curMvLX) and the neighbor motion vector (nbrMvLX), and if(SAD > Th2), thenAdaptive Nbr Weights = (Fixed Nbr Weights * Th2 SAD,Current subblock weights = 1 - Adaptive Nbr Weights, wherein ‘Fixed Nbr Weights' denotes fixed neighbor blending weights for OBMC, and Th2 is a second threshold.

12. A method for video decoding, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and always applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, provided the current CU is not predicted in intra mode or intrablock copy (IBC) mode.

13. The method of claim 12, wherein OBMC is not restricted for current CU sizes less than 32, including 4x4, 4x8, or 8x14.

14. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for an internal subblock (SubCU) in the current CU: generating motion compensated reference samples based on Decoder-side Motion Vector Refinement (DMVR) and bilinear motion compensation; applying OBMC by reusing the motion compensated reference samples generated from the DMVR motion compensation.

15. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: generating current MV reference samples (Xc) and neighbor MV reference samples (Xn); and if OBMC is enabled, then:generating samples Xo by applying OBMC blending weights to the Xc and Xn samples; and applying motion-compensation interpolation filtering to the Xo samples.

16. The method of claim 15, wherein generating sub-pixel samples Xo further comprises: for a given forward or backward direction, LX, (LX = LO or LI), deriving differences of subpixel locations of a neighbor MV (nbrMVLX), and a current MV (curMVLX) as:SubpelDeltax = nbrSubpelx — curSubpelx, SubpelDeltay = nbrSubpely — curSubpely, whereingenerating the realigned neighbor MV reference samples (X’n) based on the neighbor MV reference samples (Xn), SubpelDeltax, and SubpelDeltay, blending the realigned MV neighbor reference samples with the current reference samples using existing OBMC weights to generate the overlap-blended reference samples Xo; and applying sub-pixel motion compensation interpolation using the overlap-blended reference samples to derive the inter-prediction samples of the current block.

17. The method of claim 16, wherein the realigned neighbor MV reference samples (X’n) are generating using bilinear interpolation.

18. The method of claim 16, wherein for a subblock CU of the current CU the blending is performed for a left, top, right, and neighbor subblock CU to the subblock CU.

19. A method for video decoding using inter prediction, the method comprising: accessing a current coded unit (CU) and neighboring CUs; and applying overlapped block motion compensation (OBMC) to generate predicted values for the current CU, wherein applying OBMC comprises: for a subblock (SubCU) in the current CU with one or more neighbor SubCUs:accessing motion-vector (MV) related information from the SubCU and the one or more neighbor SubCUs, including inter-direction, reference index information, and MV values; creating a list of Max_count best neighbor SubCUs (Best_neigh_subblock[]) using a hierarchical decision process that is based on the inter direction information, the reference index information, and motion- vector difference information between motion vectors of the SubCU and its neighbor SubCUs; and performing OBMC using only the Max_count best neighbor SubCUs.

20. The method of claim 19, wherein Max_count = 1.

21. The method of claim 19, wherein Max_count is at least 1 but smaller than 4.

22. The method of claim 19, wherein the hierarchical decision process examines neighbor SubCUs using a top, left, bottom, and right sequence order.

23. The method of claim 19, wherein the hierarchical decision process comprises: set idx = 0; while (idx < Max_count) { for each neighbor SubCU: compare inter direction between the SubCU and the neighbor SubCU; if different, add the neighbor SubCU to Best_neigh_subblock[] and increment idx;} while (idx < Max_count) { for each neighbor SubCU that is not part of Best_neigh_subblock[]: compare the reference index between the SubCU and the neighbor SubCU; if different, add the neighbor to Best_neigh_subblock[] and increment idx;} if (idx < Max_count) { sort all M neighbor SubCUs that are not part of Best_neigh_subblock[] in a list (neigh_subblock_sorted[]) in descending order based on sum of absolute MV differences between the SubCU and the neighbor SubCU; let absMvd_sorted[fc] be the sum of absolute MV differences corresponding to neigh_subblock_sorted[fc], wherein k = 0, 1, ..., M-l;while (idx < Max_count) { for a j-th neighbor SubCU in neigh_subblock_sorted[] : if absMvd_sorted[ / ] > Th, where Th denotes a threshold;Best_neigh_subblock[z ] = neigh_subblock_sorted[ / ] and increment idx;}}•24. A tangible computer-readable storage medium having stored thereon computerexecutable instructions for executing with one or more processors a method in accordance with any one of the methods recited in claims 1-23.

25. An apparatus comprising a processor and configured to perform any one of the methods recited in claims 1-23.

Images