Skip mode signaling

Abstract

A method of video processing is described. The method includes performing a conversion between a video block of a video and a coded representation of the video, wherein the coded representation conforms to a format rule that specifies to selectively include, in the coded representation, an indication of a skip mode coded for the video block based on dimensions of the video block, wherein the skip mode coded allows the conversion to be performed without generating or coding a residual for the video block.

Description

[0001] Cross-references to related applications

[0002] In accordance with applicable patent law and / or the rules applicable to the Paris Convention, this application promptly claims priority and interest in International Patent Application No. PCT / CN2019 / 105825, filed September 13, 2019, and International Patent Application No. PCT / CN2019 / 107107, filed September 20, 2019. The entire disclosure of the aforementioned applications is incorporated herein by reference as part of the disclosure of this application. Technical Field

[0003] This document covers video and image encoding and decoding technologies. Background Technology

[0004] Digital video accounts for the largest share of bandwidth usage on the internet and other digital communication networks. As the number of connected user devices capable of receiving and displaying video increases, the bandwidth demand for digital video is expected to continue to grow. Summary of the Invention

[0005] This paper describes devices, systems, and methods related to digital video encoding and decoding, and particularly devices, systems, and methods related to juxtaposed motion vectors in video encoding and decoding. The described methods can be applied to existing video encoding and decoding standards (e.g., High Efficiency Video Codec (HEVC)) and future video encoding and decoding standards (e.g., Multi-Functional Video Codec (VCC)) or codecs.

[0006] In one exemplary aspect, a video processing method is disclosed. The method includes performing a conversion between video blocks of a video and a codec representation of the video, wherein the codec representation conforms to a format rule that specifies that an indication of skip-mode codec of the video blocks is selectively included in the codec representation based on the dimensions of the video blocks, wherein the skip-mode codec allows the conversion to be performed without generating or encoding / decoding residuals of the video blocks.

[0007] In another exemplary aspect, a video processing method is disclosed. The method includes a conversion between video blocks of a video and a codec representation of the video; determining the suitability of a particular codec tool for video blocks that are a first color component of the video, based on whether a particular codec tool is applied to one or more corresponding video blocks that are a second color component of the video; and performing the conversion based on the determination.

[0008] In yet another example aspect, a video processing method is disclosed. The method includes determining, for a conversion between a chroma video block of a video and a coded representation of the video, that a position dependent prediction combination (PDPC) method for the coded chroma video block is not allowed due to a corresponding luma block being coded using a particular coding mode; and performing the conversion based on the determination, wherein the PDPC method combines neighboring samples with a prediction signal of the chroma video block to generate a refined prediction signal of the chroma video block.

[0009] In yet another example aspect, a video processing method is disclosed. The method includes performing a conversion between a video block of a video and a coded representation of the video, wherein the coded representation conforms to a format rule that specifies that a coding condition that the video block satisfies includes an indication that is set to false indicating that a default half-pel interpolation filter is used instead of an optional half-pel interpolation filter.

[0010] In yet another example aspect, a video processing method is disclosed. The method includes performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein a prediction vector of the video block is generated based on a weighted average of prediction vectors of a plurality of partitions of the video block, wherein at least one partition is angularly split, and wherein the rule specifies that an optional half-pel interpolation filter is used for interpolating sample values at half-pel positions when determining the prediction vector.

[0011] In yet another example aspect, a video processing method is disclosed. The method includes performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein the rule specifies an indication of a coding condition applied to a motion vector prediction candidate to be added to a Merge list based on information associated with one or more motion candidates present in the Merge list.

[0012] In yet another example aspect, a video processing method is disclosed. The method includes determining, for a conversion between a video block of a video and a coded representation of the video, a control point motion vector of a control point of the video block coded using an affine Merge mode based on motion information of neighboring blocks of the video block according to a rule, and performing the conversion based on the determination, wherein the rule specifies that an indication of using an optional half-pel interpolation filter for the video block is set equal to an indication of a motion vector in the neighboring blocks.

[0013] In yet another example aspect, a video processing method is disclosed. The method includes performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein the rule specifies that an indication of using an optional half-pel interpolation filter for the video block is inherited from a neighboring block of the video block if the video block is coded using an affine Merge mode inherited from the neighboring block.

[0014] In yet another example aspect, a video method is disclosed. The method includes deriving motion information for a video block of a video by checking Merge candidates during a Merge candidate construction process according to a rule; and performing a conversion between the video block and a coded representation of the video, wherein the rule provides that two Merge candidates being compared are considered different during the Merge candidate construction process if an indication of usage of a selectable half-pixel interpolation filter for the two Merge candidates is different.

[0015] In yet another example aspect, the methods described above can be implemented by a video encoder apparatus comprising a processor.

[0016] In yet another example aspect, the methods can be embodied in the form of processor-executable instructions and stored on a computer-readable program medium.

[0017] These and other aspects are described further in this document. BRIEF DESCRIPTION OF DRAWINGS

[0018] Figure 1 A block diagram of an example encoder is shown.

[0019] Figure 2 An example of 67 intra prediction modes is shown.

[0020] Figure 3 Examples of horizontal and vertical run-length scanning are shown.

[0021] Figure 4 An example of motion vector scaling for temporal Merge candidates is shown.

[0022] Figure 5 An example of candidate positions for temporal Merge candidates is shown.

[0023] Figure 6A An example of spatial neighboring blocks used by alternative temporal motion vector prediction (ATMVP) is shown.

[0024] Figure 6B An example of deriving sub-CU motion fields is shown.

[0025] Figure 7 An example of search points for Merge using motion vector difference (MMVD) mode is shown.

[0026] Figure 8 A flowchart of an example of a video processing method.

[0027] Figure 9 A flowchart of another example of a video processing method.

[0028] Figure 10is a flowchart of yet another example of a video processing method.

[0029] Figure 11 is a flowchart of yet another example of a video processing method.

[0030] Figure 12 is a flowchart of yet another example of a video processing method.

[0031] Figure 13 is a flowchart of yet another example of a video processing method.

[0032] Figure 14A and 14B is a block diagram of an example of a hardware platform for visual media decoding to implement the visual media encoding techniques described in this document.

[0033] Figure 15 An example of triangle partitioning based on inter prediction is shown.

[0034] Figure 16 An example of uni-prediction MV selection for triangle partitioning mode is shown.

[0035] Figure 17 An example of weights used in the blending process is shown.

[0036] Figure 18 An example of a location to inherit affine motion prediction values is shown.

[0037] Figure 19 An example of control point motion vector inheritance is shown.

[0038] Figure 20 An example of positioning to construct candidate locations for affine Merge mode is shown.

[0039] Figures 21A-21E A flowchart of an example method of video processing based on some implementations of the disclosed technology is shown. DETAILED DESCRIPTION

[0040] This document provides various techniques that can be used by decoders of a picture or video bitstream to improve the quality of decompressed or decoded digital video or pictures. For brevity, the term “video” is used herein to include a series of pictures (traditionally known as video) and a single picture. In addition, a video encoder can also implement these techniques during the encoding process in order to reconstruct decoded frames for further encoding.

[0041] For ease of understanding, section headings are used in this document, and the implementations and techniques are not limited to the sections in which the implementations and techniques are described. As such, implementations from one section can be combined with implementations from other sections.

[0042] 1. ABSTRACT

[0043] This document is related to video coding technology. In particular, this document is related to collected motion vectors and other coding tools. This document can be applied to existing video coding standards, such as HEVC, or standards under finalization (Versatile Video Coding). This document can also be applicable to future video coding standards or video coders.

[0044] 2. PRIOR DISCUSSION

[0045] Video coding standards have evolved mainly through the development of the well-known ITU-T and ISO / IEC standards. ITU-T produced H.261 and H.263 standards, ISO / IEC produced MPEG-1 and MPEG-4 Visual, and the two organizations jointly produced the H.262 / MPEG-2 Video standard and the H.264 / MPEG-4 Advanced Video Coding (AVC) and H.265 / HEVC standards. Since H.262, the video coding standards are based on the hybrid video coding structure wherein temporal prediction is used in addition to transform coding. To explore future video coding technologies beyond HEVC, the Joint Video Exploration Team (JVET) was founded by VCEG and MPEG jointly in 2015. Since then, many new methods have been adopted by JVET and applied to the reference software named Joint Exploration Model (JEM). In April 2018, the Joint

[0046] 2.1 Color Space and Chroma Subsampling

[0047] A color space, also called a color model (or color system), is an abstract mathematical model that simply describes a range of colors as a tuple of numbers, typically 3 or 4 values or color components (e.g. RGB). In essence, a color space is a refinement of a coordinate system and subspaces.

[0048] For video compression, the most commonly used color spaces are YCbCr and RGB.

[0049] YCbCr, Y’CbCr or Y Pb / Cb Pr / Cr, also called YCBCR or Y’CBCR, is a series of color spaces used as part of a color picture pipeline in video and digital picture systems. Y’ is the luma component, CB and CR are the blue-difference and red-difference chroma components. Y’ (with the prime) is not the same as Y, which is luminance, meaning that the light intensity is non-linearly encoded based on the RGB primaries with gamma correction.

[0050] Chroma subsampling is a practice of encoding pictures with lower resolution of chroma information than luminance information, taking advantage of the fact that the human visual system is less sensitive to color differences than luminance. 2.1.1 4:4:4

[0052] Each of the three Y'CbCr components has the same sampling rate, so there is no chroma subsampling. This scheme is sometimes used in high-end film scanners and in film post-production. 2.1.2 4:2:2

[0054] The two chroma components are sampled at half the sampling rate of the luminance: horizontal chroma resolution is halved. This reduces the bandwidth of the uncompressed video signal by one third, with little or no visual difference. 2.1.3 4:2:0

[0056] In 4:2:0, the horizontal sampling is doubled compared to 4:1:1, but the vertical resolution is halved because in this scheme, the Cb and Cr channels are only sampled on every alternate line. Thus, the data rate is the same. Cb and Cr are subsampled by a factor of 2 in both horizontal and vertical directions. There are three variants of the 4:2:0 scheme, with different horizontal and vertical positioning.

[0057] • In MPEG-2, the Cb and Cr are horizontally co-located. Cb and Cr are located between the pixels in the vertical direction (in the middle).

[0058] • In JPEG / JFIF, H.261 and MPEG-1, Cb and Cr are located in the middle between alternate luminance samples.

[0059] • In 4:2:0 DV, Cb and Cr are co-located horizontally. In the vertical direction, they are co-located on alternate lines.

[0060] 2.2 Encoding and decoding process of a typical video codec

[0061] Figure 1 An example of the encoder block diagram of VVC is shown, which contains three in-loop filters: Deblocking Filter (DF), Sample Adaptive Offset (SAO) and ALF. Unlike DF, which uses a pre-defined filter, SAO and ALF utilize the original samples of the current picture to reduce the mean square error between the original and reconstructed samples by adding an offset and applying a Finite Impulse Response (FIR) filter, respectively, and signal the offset and filter coefficients using codec side information. ALF is located at the last processing stage of each picture and can be considered as a tool that tries to capture and fix artifacts created by the previous stages.

[0062] 2.3 Intra mode coding with 67 intra prediction modes

[0063] To capture arbitrary edge directions present in natural videos, the number of directional intra modes is extended from 33 used in HEVC to 65. The additional directional modes are depicted as dashed arrows in Figure 2 and the planar mode and DC mode remain the same. These dense directional intra prediction modes are applied for all block sizes and for both luma intra prediction and chroma intra prediction.

[0064] As shown in Figure 2 , the regular angular intra prediction directions are defined as 45 degrees to -135 degrees in a clockwise direction. In VTM6, several regular angular intra prediction modes are adaptively replaced with wide-angle intra prediction modes for non-square blocks. The replaced modes are signaled using the original method and remapped to the indices of wide-angle modes after parsing. The total number of intra prediction modes is unchanged, i.e., 67, and the intra mode coding is unchanged.

[0065] In HEVC, each intra coded block has a square shape and its side length is a power of 2. Therefore, generating the intra prediction value using the DC mode does not require a division operation. In VVC, the block can have a rectangular shape and in general case, a division operation is needed for each block. To avoid the division operation for DC prediction, only the longer side is used to calculate the average value for non-square blocks.

[0066] 2.4 Inter prediction

[0067] For each inter predicted CU, the motion parameters include the motion vector, the reference picture index and the reference picture list usage index, and additional information required for the new coding features of VVC for inter prediction sample generation. The motion parameters can be signaled in an explicit or implicit manner. When a CU is coded using the skip mode, the CU is associated with one PU and does not have significant residual coefficients, coded motion vector delta or reference picture index. The Merge mode is specified, where the motion parameters of the current CU are obtained from neighboring CUs, including spatial candidates and temporal candidates, and additional scheduling introduced in VVC. The Merge mode can be applied to any inter predicted CU, not just for the skip mode. The alternative to the Merge mode is the explicit transmission of the motion parameters, where the motion vector, the corresponding reference picture index for each reference picture list and the reference picture list usage flag and other required information are explicitly signaled per CU.

[0068] 2.5 Intra block copy (IBC)

[0069] Intra block copy (IBC) is a tool adopted in the HEVC extension on SCC. It is well known that it significantly improves the coding efficiency of screen content material. Since IBC mode is implemented as a block-level coding mode, block matching (BM) is performed at the encoder to find the preferred block vector (or motion vector) for each CU. Here, the block vector is used to indicate the displacement from the current block to the reference block, which has already been reconstructed within the current picture. The luma block vector of an IBC-coded CU is integer-precision. The chroma block vector is also rounded to integer precision. When used in conjunction with AMVR, the IBC mode can switch between 1-pel and 4-pel motion vector precision. An IBC-coded CU is considered as a third prediction mode in addition to the intra or inter prediction modes. IBC mode is applicable to a CU whose width and height are both less than or equal to 64 luma samples.

[0070] At the encoder side, hash-based motion estimation is performed for IBC. The encoder performs RD check for blocks whose width or height is not larger than 16 luma samples. For non-Merge mode, block vector search is first performed using hash-based search. If hash search does not return a valid candidate, a local search based on block matching will be performed.

[0071] In hash-based search, the hash key value match (32-bit CRC) between the current block and the reference block is extended to all allowed block sizes. The hash key computation for each location in the current picture is based on 4x4 sub-blocks. For larger size current blocks, when all hash keys of all 4x4 sub-blocks match the hash keys in the corresponding reference locations, the hash key is determined to match the hash key of the reference block. If multiple reference blocks are found whose hash keys match the hash key of the current block, the block vector cost of each matching reference is computed and the matching reference with the minimum block vector cost is selected.

[0072] In block matching search, the search range is set to cover both the previous CTU and the current CTU.

[0073] At the CU level, the IBC mode is signaled by a flag and it can be signaled as IBC AMVP mode or IBC skip / Merge mode as follows:

[0074] - IBC skip / Merge mode: The Merge candidate index is used to indicate which block vectors from the neighboring candidate IBC-coded blocks in the list are used to predict the current block. The Merge list consists of spatial candidates, HMVP candidates and paired candidates.

[0075] - IBC AMVP mode: The block vector difference is coded in the same way as the motion vector difference. The block vector prediction method uses two candidates as the predictor, one from the left neighbor and one from the top neighbor (if IBC coded). When either neighbor is not available, the default block vector is used as the predictor. A flag is signaled to indicate the block vector predictor index.

[0076] 2.6 Palette mode

[0077] For palette mode signaling, the palette mode is coded as the prediction mode of the coding unit, i.e. the prediction mode of the coding unit can be MODE_INTRA, MODE_INTER, MODE_IBC and MODE_PLT. If palette mode is used, the pixel values in the CU are represented by a small set of representative color values. This set is called the palette. For pixels with values close to the palette colors, a palette index is signaled. For pixels with values outside the palette, the pixel is represented with an escape symbol and the quantized pixel value is signaled directly.

[0078] To decode a palette coded block, the decoder needs to decode the palette colors and the indices. The palette colors are described by a palette table and coded by the palette table coding tool. An escape flag is signaled for each CU to indicate whether there is an escape symbol in the current CU. If there is an escape symbol, the palette table will be increased by one and the last index is assigned to the escape mode. The palette indices of all pixels in the CU form a palette index map and are coded by the palette index map coding tool.

[0079] For the coding of the palette table, a palette predictor is maintained. The predictor is initialized at the beginning of each slice, where the predictor is reset to 0. For each entry in the palette predictor, a reuse flag is signaled to indicate whether it is part of the current palette. The reuse flag is sent using run-length coding of zeros. After that, the number of new palette entries is signaled using an exponential Golomb code of order 0. Finally, the component values of the new palette entries are signaled. After the current CU is coded, the palette predictor is updated with the current palette and the entries from the previous palette predictor that are not reused in the current palette will be added at the end of the new palette predictor until the allowed maximum size is reached (palette filling).

[0080] To code the palette index map, the indices are coded using a horizontal traversal scan and a vertical traversal scan as shown in Figure 3 The scan order is explicitly signaled in the bitstream using the palette_transpose_flag.

[0081] Two main palette sample mode are used to code the palette index: "INDEX" and "COPY_ABOVE". The mode is signaled using a flag except for the top row when using horizontal scan, the first column when using vertical scan, or the previous mode is "COPY_ABOVE". In "COPY_ABOVE" mode, the palette index of the sample in the above row is copied. In "INDEX" mode, the palette index is signaled explicitly. For both "INDEX" and "COPY_ABOVE" mode, a run value is signaled, which specifies the number of pixels coded using the same mode.

[0082] The coding order of the index map is as follows: first, the number of index values of the CU is signaled. Then the actual index values of the whole CU are signaled using truncated binary coding. Both the index number and the index values are coded in bypass mode. This groups the index related bypass bins together. Then the palette mode (INDEX or COPY_ABOVE) and the run are signaled in a cross fashion. Finally, the component escape values corresponding to the escape samples of the whole CU are grouped together and coded in bypass mode. After signaling the index values, an additional syntax element, last_run_type_flag, is signaled. This syntax element is used in combination with the index number and does not need to signal the run value corresponding to the last run in the block.

[0083] In VTM5.0, bi-tree is enabled for I slices, which partitions the coding units of luma and chroma separately. Therefore, in this scheme, palette is applied to luma (Y component) and chroma (Cb and Cr components) separately. If bi-tree is disabled, palette is applied to Y, Cb, Cr components jointly, as in HEVC palette.

[0084] 2.7 Temporal motion vector prediction (TMVP) in VVC

[0085] In the derivation process of this temporal Merge candidate, a scalar motion vector is derived based on a collocated CU belonging to a collocated reference picture. The reference picture list used to derive the collocated CU is explicitly signaled in the slice header. As shown by the dashed line in Figure 4 The scalar motion vector used for the temporal Merge candidate is obtained by scaling it according to the motion vectors of the collocated CU using POC distances tb and td, where tb is defined as the POC difference between the reference picture of the current picture and the current picture, and td is defined as the POC difference between the collocated picture and the reference picture of the collocated picture. The reference picture index of the temporal Merge candidate is set equal to zero.

[0086] As shown in Figure 5The position of the temporal candidate is selected between candidates CO and CI as shown. If the CU at position CO is not available, intra coded or outside the current row of the CTU, position CI is used. Otherwise, position CO is used for the derivation of the temporal Merge candidate.

[0087] 2.8 Subblock-based Temporal Motion Vector Prediction (SbTMVP) in VVC

[0088] VTM supports a subblock-based temporal motion vector prediction (SbTMVP) method. Similar to the temporal motion vector prediction (TMVP) in HEVC, SbTMVP uses the motion field in the collocated picture to improve the motion vector prediction and Merge mode for a CU in the current picture. The same collocated picture used by TMVP is used for SbTVMP. SbTMVP is different from TMVP in the following two main aspects:

[0089] 1. TMVP predicts the motion at the CU level, but SbTMVP predicts the motion at the sub-CU level;

[0090] 2. While TMVP obtains the temporal motion vector from a collocated block in the collocated picture (the collocated block is either the bottom-right block or the center block with respect to the current CU), SbTMVP applies a motion displacement before obtaining the temporal motion information from the collocated picture, where the motion displacement is obtained from the motion vector of one of the spatial neighboring blocks from the current CU.

[0091] Figures 6A-6B The SbTVMP process is illustrated in Figure 6A . SbTMVP predicts the motion vector of a sub-CU within the current CU in two steps. In the first step, the spatial neighbor Al in

[0092] is checked. If Al has a motion vector that uses the collocated picture as its reference picture, this motion vector is selected as the motion displacement to be applied. If no such motion is identified, the motion displacement is set to (0, 0). Figure 6B Figure 6B In the second step, the motion displacement identified in step 1 is applied (i.e., added to the coordinates of the current block) to obtain the sub-CU level motion information (motion vector and reference index) from the collocated picture as shown in

[0093] ​In VTM6, the combined subblock-based Merge list containing both SbTMVP candidates and affine Merge candidates is used for signaling the subblock-based Merge mode. SbTMVP mode is enabled / disabled by a sequence parameter set (SPS) flag. If SbTMVP mode is enabled, SbTMVP predictor is added as the first entry of the list of subblock-based Merge candidates, and is followed by affine Merge candidates. The size of the subblock-based Merge list is signaled in the SPS, and the maximum allowed size of the subblock-based Merge list is 5 in VTM6.

[0094] The sub-CU size used in SbTMVP is fixed to 8x8, and as with affine Merge mode, SbTMVP mode is only applicable to CUs with both width and height greater than or equal to 8.

[0095] The coding logic of the additional SbTMVP Merge candidate is the same as other Merge candidates, i.e., for each CU in P slice or B slice, an additional RD check is performed to decide whether to use the SbTMVP candidate.

[0096] Description of TMVP and SbTMVP in working draft.

[0097] 8.5.2.11 Derivation process of temporal luma motion vector prediction

[0098] Inputs of this process:

[0099] - the luma position (xCb, yCb) of the top-left sample of the current luma coding block relative to the top-left luma sample of the current picture,

[0100] - the variable cbWidth specifying the width of the current coding block in luma samples,

[0101] - the variable cbHeight specifying the height of the current coding block in luma samples,

[0102] - the reference index refldxLX, where X is 0 or 1.

[0103] Outputs of this process:

[0104] - the motion vector predictor mvLXCol at 1 / 16 fractional sample precision,

[0105] - the availability flag availableFlagLXCol.

[0106] The variable currCb specifies the current luma coding block at luma position (xCb, yCb).

[0107] The variables mvLXCol and availableFlagLXCol are derived as follows:

[0108] - If slice_temporal_mvp_enabled_flag is equal to 0 or (cbWidth * cbHeight) is less than or equal to 32, both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0109] - Otherwise (slice_temporal_mvp_enabled_flag is equal to 1), the following sequential steps apply:

[0110] 1. The right-bottom collocated motion vector and the right and bottom boundary sample positions are derived as follows:

[0111] xCb + cbWidth (8-421)

[0112] yColBr = yCb + cbHeight (8-422)

[0113] rightBoundaryPos = subpic_treated_as_pic_flag[SubPicIdx]? SubPicRightBoundaryPos : pic_width_in_luma_samples - 1 (8-423)

[0114] botBoundaryPos = subpic_treated_as_pic_flag[SubPicIdx]? SubPicBotBoundaryPos : pic_height_in_luma_samples - 1 (8-424)

[0115] - If yCb » CtbLog2SizeY is equal to yColBr » CtbLog2SizeY, yColBr is less than or equal to botBoundaryPos and xColBr is less than or equal to rightBoundaryPos, the following applies:

[0116] - The variable colCb specifies the luma coding block that covers the modified location given by ((xColBr » 3) « 3, (yColBr » 3) « 3) within the collocated picture specified by ColPic.

[0117] - the luma position ( xColCb, yColCb ) is set equal to the luma position of the top-left sample of the collocated luma coding block specified by colCb with respect to the top-left luma sample of the collocated picture specified by ColPic.

[0118] - the derivation process of collocated motion vector specified in clause 8.5.2.12 is invoked with currCb, colCb, ( xColCb, yColCb ), refldxLX and sbFlag set equal to 0 as inputs and the outputs assigned to mvLXCol and availableFlagLXCol.

[0119] - Otherwise, both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0120] 2. When availableFlagLXCol is equal to 0, the central collocated motion vector is derived as follows:

[0121] xColCtr = xCb + ( cbWidth » 1 ) (8-425)

[0122] yColCtr = yCb + ( cbHeight » 1 ) (8-426)

[0123] - the variable colCb specifies the luma coding block that covers the modified location given by ( ( xColCtr » 3 ) « 3, ( yColCtr » 3 ) « 3 ) within the collocated picture specified by ColPic.

[0124] - the luma position ( xColCb, yColCb ) is set equal to the luma position of the top-left sample of the collocated luma coding block specified by colCb with respect to the top-left luma sample of the collocated picture specified by ColPic.

[0125] - the derivation process of collocated motion vector specified in clause 8.5.2.12 is invoked with currCb, colCb, ( xColCb, yColCb ), refldxLX and sbFlag set equal to 0 as inputs and the outputs assigned to mvLXCol and availableFlagLXCol.

[0126] 8.5.2.12 Derivation process of collocated motion vector

[0127] Inputs of this process:

[0128] - the variable currCb specifying the current coding block,

[0129] - the variable colCb specifying a collocated coding block within the collocated picture specified by ColPic,

[0130] - the luma position (xColCb, yColCb) of the top-left sample of the collocated luma coding block specified by colCb, relative to the top-left luma sample of the collocated picture specified by ColPic,

[0131] - the reference index refldxLX, where X is either 0 or 1,

[0132] - the flag sbFlag indicating a subblock temporal merge candidate.

[0133] The outputs of this process are:

[0134] - the motion vector predictor mvLXCol at 1 / 16 fractional sample precision,

[0135] - the availability flag availableFlagLXCol.

[0136] The variable currPic specifies the current picture.

[0137] The arrays predFlagL0Col[x][y], mvL0Col[x][y] and refldxL0Col[x][y] are set equal to predFlagl10[x][y], MvDmvrL0[x][y] and refldxl10[x][y] of the collocated picture specified by ColPic, respectively, and the arrays predFlagL1Col[x][y], mvL1Col[x][y] and refldxL1Col[x][y] are set equal to PredFlagL1[x][y], MvDmvrL1[x][y] and RefldxL1[x][y] of the collocated picture specified by ColPic, respectively.

[0138] The variables mvLXCol and availableFlagLXCol are derived as follows:

[0139] - If colCb is coded with intra or IBC prediction mode, both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0140] - Otherwise, the motion vector mvCol, the reference index refldxCol and the reference list identifier listCol are derived as follows:

[0141] 2.8.1 Derivation of collocated motion vector when colCb is coded in inter blocks

[0142] – If sbFlag is equal to 0, availableFlagLXCol is set equal to 1 and the following applies:

[0143] – If predFlagL0Col[ xColCb ][ yColCb ] is equal to 0, mvCol, refldxCol and listCol are set equal to mvL1Col[ xColCb ][ yColCb ], refldxL1Col[ xColCb ][ yColCb ] and L1, respectively.

[0144] – Otherwise, if predFlagL0Col[ xColCb ][ yColCb ] is equal to 1 and predFlagL1Col[ xColCb ][ yColCb ] is equal to 0, mvCol, refldxCol and listCol are set equal to mvL0Col[ xColCb ][ yColCb ], refldxL0Col[ xColCb ][ yColCb ] and L0, respectively.

[0145] – Otherwise (predFlagL0Col[ xColCb ][ yColCb ] is equal to 1 and predFlagL1Col[ xColCb ][ yColCb ] is equal to 1), the following assignments are made:

[0146] – If NoBackwardPredFlag is equal to 1, mvCol, refldxCol and listCol are set equal to mvLXCol[ xColCb ][ yColCb ], refldxLXCol[ xColCb ][ yColCb ] and LX, respectively.

[0147] – Otherwise, mvCol, refldxCol and listCol are set equal to mvLNCol[ xColCb ][ yColCb ], refldxLNCol[ xColCb ][ yColCb ] and LN, respectively, where N is the value of collocated_from_l0_flag.

[0148] – Otherwise (sbFlag is equal to 1), the following applies:

[0149] – If sbFlag is equal to 0, availableFlagLXCol is set equal to 1 and the following applies:

[0150] - If PredFlagLXCol[ xColCb ][ yColCb ] is equal to 1, mvCol, refldxCol and listCol are set equal to mvLXCol[ xColCb ][ yColCb ], refldxLXCol[ xColCb ][ yColCb ] and LX, respectively, and availableFlagLXCol is set equal to 1.

[0151] - Otherwise (PredFlagLXCol[ xColCb ][ yColCb ] is equal to 0), the following applies:

[0152] - If NoBackwardPredFlag is equal to 1 and PredFlagLYCol[ xColCb ][ yColCb ] is equal to 1, mvCol, refldxCol and listCol are set equal to mvLYCol[ xColCb ][ yColCb ], refldxLYCol[ xColCb ][ yColCb ] and LY, respectively, where Y is equal to!X, where X is the value of X that called this process, and availableFlagLXCol is set equal to 1.

[0153] - Otherwise, both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0154] - When availableFlagLXCol is equal to TRUE, mvLXCol and availableFlagLXCol are derived as follows:

[0155] - If LongTermRefPic( currPic, currCb, refldxLX, LX ) is not equal to LongTermRefPic( ColPic, colCb, refldxCol, listCol ), both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0156] - Otherwise, the variable availableFlagLXCol is set equal to 1, refPicList[ listCol ][ refldxCol ] is set equal to the picture with reference index refldxCol in the reference picture list listCol containing the slice of the collocated picture ColPic specifying the collocated picture of the coding block colCb, and the following applies:

[0157] colPocDiff = DiffPicOrderCnt( ColPic, refPicList[ listCol ][ refIdxCol ] ) (8-427)

[0158] currPocDiff = DiffPicOrderCnt( currPic, RefPicList[ X ][ refIdxLX ] ) (8-428)

[0159] - Invokes the temporal motion buffering compression process of collocated motion vectors specified in subclause 8.5.2.15 with mvCol as input and modified mvCol as output.

[0160] - If RefPicList[ X ][ refIdxLX ] is a long-term reference picture, or colPocDiff is equal to currPocDiff, mvLXCol is derived as follows:

[0161] mvLXCol = mvCol (8-429)

[0162] - Otherwise, mvLXCol is derived as a scaled version of the motion vector mvCol as follows:

[0163] tx = ( 16384 + ( Abs( td ) » 1 ) ) / td (8-430)

[0164] distScaleFactor = Clip3( -4096, 4095, ( tb * tx + 32 ) » 6 ) (8-431)

[0165] mvLXCol = Clip3( -131072, 131071, ( distScaleFactor * mvCol + 128 - ( distScaleFactor * mvCol > 0 ) ) » 8 ) (8-432)

[0166] where td and tb are derived as follows:

[0167] td = Clip3( -128, 127, colPocDiff ) (8-433)

[0168] tb = Clip3( -128, 127, currPocDiff ) (8-434)

[0169] 2.9 Bi-prediction with CU-level weights (BCW)

[0170] In HEVC, a bi-prediction signal is generated by averaging and / or using two different motion vectors obtained from two different reference pictures. In VTM6, the bi-prediction mode is extended beyond simple averaging to allow a weighted average of the two prediction signals.

[0171] P bi-pred = ((8 - w) * P0 + w * P1 + 4) » 3 (3-19)

[0172] Five weights are allowed in the weighted average bi-prediction, w e {-2, 3, 4, 5, 10}. For each bi-predicted CU, the weight w is determined by one of two ways: 1) for non-Merge CU, the weight index is signaled after the motion vector difference; 2) for Merge CU, the weight index is inferred from neighboring blocks based on the Merge candidate index. Weighted average bi-prediction is only applied to CUs with 256 or more luma samples (i.e., CU width times CU height is greater than or equal to 256). For low-delay pictures, all 5 weights are used. For non-low-delay pictures, only 3 weights (w e {3, 4, 5}) are applied.

[0173] - At the encoder, fast search algorithms are applied to find the weight index without significantly increasing the complexity of the encoder. These algorithms are summarized as follows. For more details, the reader is referred to the VTM software and document JVET-L0646. When used in combination with AMVR, unequal weights are only conditionally checked for 1-pixel and 4-pixel motion vector precision if the current picture is a low-delay picture.

[0174] - When combined with affine, affine ME is performed on unequal weights if and only if the affine mode is selected as the current best mode.

[0175] - When the two reference pictures in bi-prediction are the same, unequal weights are only conditionally checked.

[0176] - When certain conditions are met, unequal weights are not searched, depending on the POC distance between the current picture and its reference pictures, the coding QP, and the temporal level.

[0177] The BCW weight index is coded using context-coded bins and then bypass-coded bins. The first context-coded bin indicates whether equal weights are used; if unequal weights are used, additional bins are signaled using bypass coding to indicate which unequal weight is used.

[0178] Weighted prediction (WP) is a coding tool supported in H.264 / AVC and HEVC standards to efficiently code fading video content. The support of WP is also added to VVC standard. WP allows signaling of weighting parameters (weight and offset) for each reference picture in each reference picture list L0 and L1. Then, the weight and offset of the corresponding reference picture are applied during motion compensation. WP and BCW are designed for different types of video content. To avoid the interaction between WP and BCW, which would complicate the VVC decoder design, if a CU uses WP, the BCW weight index is not signaled and w is inferred to be 4 (i.e., equal weights are applied). For Merge CUs, the weight index is inferred from neighboring blocks based on the Merge candidate index. This can be applied to both normal Merge mode and inherited affine Merge mode. For constructed affine Merge mode, the affine motion information is constructed based on the motion information of up to 3 blocks. The following process is used to derive the BCW index of a CU using constructed affine Merge mode.

[0179] 1. The range of BCW indices {0, 1, 2, 3, 4} is divided into three groups {0}, {1, 2, 3} and {4}. If all control points have BCW indices from the same group, the BCW index is derived following the steps in Step 2; otherwise, the BCW index is set to 2.

[0180] If at least two control points have the same BCW index, this BCW index value is assigned to the candidate; otherwise, the BCW index of the current constructed candidate is set to 2.

[0181] 2.10 Merge mode with MVD (MMVD)

[0182] In addition to Merge mode (implicit derived motion information is directly used for prediction sample generation of the current CU), Merge mode with motion vector difference (MMVD) is introduced in VVC. MMVD flag is signaled immediately after the skip flag and the Merge flag to specify whether MMVD mode is used for the CU.

[0183] In MMVD, after a Merge candidate is selected, it is further refined by the signaled MVD information. The additional information includes the Merge candidate flag, an index for specifying the motion magnitude, and an index for the indication of the motion direction. In MMVD mode, one of the first two candidates in the Merge list is selected to be used as the MV basis. The Merge candidate flag is signaled to specify which Merge candidate flag is used.

[0184] The distance index specifies the motion magnitude information and indicates a predefined offset from the origin. As Figure 7As shown, an offset is added to the horizontal or vertical component of the starting MV. Table 1 specifies the relationship between the distance index and the predefined offset.

[0185] Table 1: Relationship between distance index and predefined offset

[0186]

[0187] The direction index indicates the direction of the MVD relative to the starting point. The direction index can indicate four directions as shown in Table 2. It is noted that the meaning of the MVD sign can change depending on the information of the starting MV. When the starting MV is a non-predicted MV or a bi-predicted MV, and both lists point to the same side of the current picture (i.e., both reference POCs are greater than or less than the POC of the current picture), the sign in Table 2 specifies the sign of the MV offset added to the starting MV. When the starting MV is a bi-predicted MV, and the two MVs point to different sides of the current picture (i.e., one reference POC is greater than the POC of the current picture while the other reference POC is less than the POC of the current picture), the sign in Table 2 specifies the sign of the MV offset added to the list0 MV component of the starting MV, and the sign of the listl MV has the opposite value.

[0188] Table 2: Sign of the MV offset specified by the direction index

[0189] Direction IDX 00 01 10 11 X axis + – N / A N / A Y axis N / A N / A + –

[0190] 2.11 Optional luma half-pel interpolation filter

[0191] In JVET-N0309, an optional half-pel interpolation filter was proposed.

[0192] The completion of the switching of the half-pel luma interpolation filter depends on the motion vector precision. In addition to the existing quarter-pel, full-pel, and 4-pel AMVR modes, a new half-pel precision AMVR mode is introduced. The optional half-pel luma interpolation filter can be selected only in the case of half-pel motion vector precision.

[0193] 2.11.1 Half-pel AMVR mode

[0194] An additional AMVR mode for non-affine non-Merge inter coded CUs is proposed that allows signaling of motion vector differences with half-pel precision. The existing AMVR scheme of the current VVC draft is directly extended by having a new context modeled binary syntax element hpel_amvr_flag indicating the use of the new half-pel AMVR mode when hpel_amvr_flag == 1 directly after the syntax element amvr_flag. Otherwise, i.e. if hpel_amvr_flag == 0, the selection between full-pel and 4-pel AMVR modes is indicated by the syntax element amvr_precision_flag as in the current VVC draft.

[0195] 2.11.2 Optional luma half-pel interpolation filter

[0196] For non-affine non-Merge inter coded CUs using half-pel motion vector precision (i.e. the half-pel AMVR mode), the value of the new syntax element if_idx is used to switch between the HEVC / VVC half-pel luma interpolation filter and one or more optional half-pel interpolation filters. The syntax element if_idx is only signaled in the case of the half-pel AMVR mode. In the case of the skip / Merge mode using spatial merging candidates, the value of the syntax element if_idx is inherited from the neighboring block.

[0197] 2.11.2.1 Test 1: One optional half-pel interpolation filter

[0198] In this test case, there is one 6-tap interpolation filter as an alternative to the normal HEVC / VVC half-pel interpolation filter. The following table shows the mapping between the value of the syntax element if_idx and the selected half-pel luma interpolation filter:

[0199] if_idx binarization filter interpolation filter coefficients 0 0 Gaussian (6-tap) [0,3,9,20,20,9,3,0] 1 1 HEVC / VVC (8-tap) [-1,4,-11,40,40,-11,4,-1]

[0200] 2.11.2.1 Test 2: Two optional half-pel interpolation filters

[0201] In this test case, there are two 8-tap interpolation filters as an alternative to the normal HEVC / VVC half-pel interpolation filter. The following table shows the mapping between the value of the syntax element if_idx and the selected half-pel luma interpolation filter:

[0202] if_idx binarization filter interpolation filter coefficients 0 0 Filter 1 (8-tap) [3,6,10,13,13,10,6,3] 1 10 Filter 2 (8-tap) [-1,-1,9,25,25,9,-1,-1] 2 11 HEVC / VVC (8-tap) [-1,4,-11,40,40,-11,4,-1]

[0203] The amvr_precision_idx is signaled to indicate whether the current CU adopts 1 / 2-pel MV precision, 1-pel MV precision or 4-pel MV precision. There are 2 binary bits to be coded.

[0204] The hpel_if_idx is signaled to indicate whether the default half-pel interpolation filter or the alternative half-pel interpolation filter is used. When 2 alternative half-pel interpolation filters are used, 2 bins need to be coded.

[0205] 2.12 Triangle partitioning for inter prediction (TPM)

[0206] In VTM6, triangle partitioning mode is supported for inter prediction. Triangle partitioning mode is only applied to CUs of 8x8 or larger. Triangle partitioning mode is signaled using a CU-level flag as a kind of Merge mode and other Merge modes including regular Merge mode, MMVD mode, CIIP mode and subblock Merge mode.

[0207] When this mode is used, the CU is uniformly partitioned into two triangular partitions using diagonal split or anti-diagonal split ( Figure 15 ). Each triangular partition in the CU is inter predicted using its own motion; each partition is only allowed uni-prediction, i.e. each partition has one motion vector and one reference index. The uni-prediction motion constraint is applied to ensure the same as regular bi-prediction, i.e. only two motion- compensated predictions are needed for each CU. The uni-prediction motion of each partition is derived using the process described in 2.12.1.

[0208] If triangle partitioning mode is used for the current CU, a flag indicating the triangle partitioning direction (diagonal or anti-diagonal) and two Merge indices (one for each partition) are further signaled. The number of maximum TPM candidates size is explicitly signaled at slice level and the syntax binarization of TMP Merge indices is specified. After each triangular partition is predicted, a blending process with adaptive weights is used to adjust the sample values along the diagonal or anti-diagonal edge. This is the prediction signal of the whole CU and as with other prediction modes, the transform and quantization processes will be applied to the whole CU. Finally, the motion field of the CU predicted using triangle partitioning mode is stored in 4x4 units as in 2.12.3.

[0209] Triangle partitioning mode is not used in combination with SBT, i.e. cu_SBT_flag is inferred to be 0 without signaling when the signaled triangle mode is equal to 1.

[0210] 2.12.1 Uni-prediction candidate list construction

[0211] The uni-prediction candidate list is derived directly from the Merge candidate list constructed according to the extended Merge prediction process. Let n denote the index of the uni-prediction motion in the triangular uni-prediction candidate list. The LX motion vector of the nth extended Merge candidate, where X equals the parity of n, is used as the nth uni-prediction motion vector for the triangular partition mode. These motion vectors are marked with "x" in Figure 16 If the corresponding LX motion vector of the nth extended Merge candidate does not exist, the L(l-X) motion vector of the same candidate is used as the uni-prediction motion vector for the triangular partition mode.

[0212] 2.12.2 Blend along the triangular partition edge

[0213] After each triangle partition is predicted using its own motion, a blend is applied to the two prediction signals to derive the samples around the diagonal or anti-diagonal edge. The following weights are used for the blend process:

[0214] {7 / 8, 6 / 8, 5 / 8, 4 / 8, 3 / 8, 2 / 8, 1 / 8} for luma, and {6 / 8, 4 / 8, 2 / 8} for chroma, as shown in Figure 17

[0215] 2.12.3 Motion field storage

[0216] The motion vectors of a CU coded in the triangular partition mode are stored in 4x4 units. Depending on the location of each 4x4 unit, either a uni-prediction motion vector or a bi-prediction motion vector is stored. Let Mvl and Mv2 denote the uni-prediction motion vectors for partition 1 and partition 2, respectively. If a 4x4 unit is located in the non-weighted region shown in the example of Figure 17 , Mvl or Mv2 is stored for this 4x4 unit. Otherwise, if the 4x4 unit is located in the weighted region, a bi-prediction motion vector is stored. The bi-prediction motion vector is derived from Mvl and Mv2 according to the following process:

[0217] (1) If Mvl and Mv2 are from different reference picture lists (one from L0 and the other from Ll), Mvl and Mv2 are simply combined to form the bi-prediction motion vector.

[0218] (2) Otherwise, if Mvl and Mv2 are from the same list, and without loss of generality, it is assumed that they are both from L0. In this case,

[0219] (2.a) If the reference picture of Mv2 (or Mvl) appears in Ll, convert this Mv2 (or Mvl) to an Ll motion vector using the reference picture in Ll. Then the two motion vectors are combined to form the bi-prediction motion vector; ​

[0220] (2.b) Otherwise, instead of bi-predictive motion, only store uni-predictive motion Mv1.

[0221] 2.13 Affine Merge Prediction

[0222] The AF_MERGE mode can be applied to a CU whose width and height are both greater than or equal to 8. In this mode, the CPMVs of the current CU are generated based on the motion information of spatial neighboring CUs. There can be up to five CPMVP candidates, and an index is signaled to indicate which one is to be used for the current CU. The following three types of CPMV candidates are used to form the affine merge candidate list:

[0223] 1) Inherited affine merge candidate inferred from the CPMVs of neighboring CUs

[0224] 2) Constructed affine merge candidate CPMVP derived using the translation MVs of neighboring CUs

[0225] 3) Zero MV

[0226] In VTM6, there are at most two inherited affine candidates, which are derived from the affine motion model of neighboring blocks, one from the left neighboring CU and the other from the above neighboring CU. The candidate blocks are shown in Figure 18 . For the left prediction value, the scan order is A0 -> A1, and for the above prediction value, the scan order is B0 -> B1 -> B2. Only the first inherited candidate from each side is selected. No de-duplication check is performed between the two inherited candidates. When a neighboring affine CU is identified, its control point motion vectors are used to derive CPMVP candidates in the affine merge list of the current CU. As shown in Figure 19 , if the neighboring left-bottom block A is coded in affine mode, the motion vectors v_2, v_3, and v_4 of the left-top, right-top, and left-bottom corners of the CU containing block A are obtained. When block A is coded using a 4-parameter affine model, two CPMVs of the current CU are computed from v_2 and v_3. If block A is coded using a 6-parameter affine model, three CPMVs of the current CU are computed from v_2, v_3, and v_4.

[0227] Constructed affine candidate refers to constructing a candidate by combining the neighboring translation motion information of each control point. The motion information of the control points is derived from Figure 20The specified spatial and temporal neighbors are derived as shown. CPMVk (k = 1, 2, 3, 4) denotes the k-th control point. For CPMV1, the B2->B3->A2 block is checked and the MV of the first available block is used. For CPMV2, the Bl->B0 block is checked and for CPMV3, the Al->A0 block is checked. For TMVP, if available, it is used as CPMV4.

[0228] After obtaining the MVs of the four control points, an affine Merge candidate is constructed based on those motion information. The following combinations of control point MVs are used to construct in order:

[0229] {CPMV1, CPMV2, CPMV3}, {CPMV1, CPMV2, CPMV4}, {CPMV1, CPMV3, CPMV4},

[0230] {CPMV2, CPMV3, CPMV4}, {CPMV1, CPMV2}, {CPMV1, CPMV3}

[0231] The combinations of 3 CPMVs form 6-parameter affine Merge candidates and the combinations of 2 CPMVs form 4-parameter affine Merge candidates. To avoid the motion scaling process, if the reference indices of control points are different, the related combinations of control point MVs are discarded.

[0232] After checking the inherited affine Merge candidates and constructing the affine Merge candidates, if the list is still not full, zero MVs are inserted at the end of the list.

[0233] 3. Drawbacks of existing implementations

[0234] The current design of collocated motion vector derivation in inter prediction has the following problems:

[0235] 1. The derivation of collocated motion vector in TMVP and SbTMVP depends on the prediction mode of the collocated block. In current VVC, if the collocated block is coded in Intra prediction mode or IBC prediction mode, the collocated motion vector is set to be equal to zero motion vector. Therefore, even if the collocated block is palette coded, it can still return an undefined collocated motion vector, because there is no motion vector associated with palette prediction mode.

[0236] 2. In BCW, the derivation of weighted sample prediction can not be efficient.

[0237] 3. In current VVC, MVs are clipped to 18 bits. However, Merge motion vector difference is clipped to 16 bits, which can lead to accuracy loss.

[0238] 4. The signaled cu_skip_flag can cause overhead bits. In current VVC, the maximum width and height of IBC coding unit is 64. For blocks with width or height larger than 64 in I slice, cu_skip_flag does not need to be signaled.

[0239] 5. The alternative luma half-pel interpolation filter flag can be set equal to true even if the CU / PU / block does not have a half-pixel or coarser MV component.

[0240] 6. The alternative luma half-pel interpolation filter can be used in TPM mode.

[0241] 7. The alternative luma half-pel interpolation filter can be used in TMVP / SbTMVP / affine Merge.

[0242] 8. BCW can be used in TMVP / SbTMVP

[0243] 4. Example method of collocated motion vector in video coding

[0244] The following detailed inventions should be considered as examples to explain the general concepts. The inventions should not be interpreted narrowly. Furthermore, the inventions can be combined in any way.

[0245] Derivation of collocated motion vector

[0246] 1. How to derive the collocated motion vector and / or the availability of the collocated motion vector can depend on whether the prediction mode of the collocated coding block is inter or not, instead of checking whether the collocated coding block is intra coded or IBC coded. In this case, instead of storing four prediction modes for each block, only one bit is required to determine whether the block is inter or non-inter.

[0247] a. In one example, for the case that the collocated coding block is coded with palette prediction mode, how to derive the collocated motion vector and / or the availability of the collocated motion vector can be the same as the case that the collocated coding block is coded with intra / IBC prediction mode.

[0248] b. In one example, when the collocated coding block is coded with non-inter prediction mode (e.g., intra, palette, or IBC), the collocated motion vector can be set as unavailable.

[0249] c. Alternatively, when the collocated coding block is coded with non-inter prediction mode (e.g., intra, palette, or IBC), the collocated motion vector can be marked as available, and the default motion vector can be specified as the collocated motion vector.

[0250] d. Alternatively, when the collocated coded block is coded in a non-inter prediction mode, other blocks (e.g., one neighboring inter coded block of the collocated coded block) can be checked.

[0251] i. In one example, the neighboring block can be the nearest inter coded block to the left / right / top / bottom of the collocated coded block.

[0252] 2. The determination of the collocated motion vector can depend on the reference list and / or reference index of the collocated coded block.

[0253] a. In one example, when the reference index of the reference list X (e.g., L1) of the collocated coded block is not equal to a specific value (e.g., 0), the collocated motion vector can be derived (e.g., using the existing technique described in 2.8.1).

[0254] b. In one example, when the reference index of the reference list X (e.g., L1) of the collocated coded block is equal to a specific value (e.g., 0), the derivation of the collocated motion vector can be invoked.

[0255] c. Alternatively, in addition, when the collocated coded block is coded in a non-inter prediction mode (including or not including IBC), or when its reference picture does not satisfy a given condition, the collocated MV is set to be unavailable.

[0256] i. Alternatively, the collocated MV is set to a default value.

[0257] Sample prediction for BCW

[0258] 3. The weight table applied in the BCW coding mode can be asymmetric.

[0259] a. In one example, for a weight W being an entry of the table, (1-W) can not be an entry of the table, where W is in the range of [a, b], where (a+b) is equal to 1. b. In one example, for a weight W being an entry of the table, (2 N -W) can not be an entry of the table, assuming that the final prediction block is generated by (W0*P0+W1*P1)>>N, where W0 and W1 are two weights applied to two prediction blocks P0 and P1 respectively; and (W0+W1) is equal to (1<<N).

[0260] 4. The weights in the weight table applied in the BCW coding mode can not be in a monotonically increasing order.

[0261] a. In one example, the (i+1)th entry of the table can have a value smaller than the ith entry of the table.

[0262] 5. In one example, the weighted sample prediction process of the BCW can depend on different weight lookup tables.

[0263] a. In one example, {4, 5, 3, 10, 2} / {4, 3, 5, 10, 2} / {4, 5, 3, 10, 1} / {4, 3, 5, 10, 1} / {4, 5, 3, 10, -1} can be used as weight lookup tables for the BCW.

[0264] 6. In one example, in the weighted sample prediction process of the BCW, the intermediate prediction samples in each prediction direction can be converted (if necessary, e.g., when the first bit depth is not equal to the bit depth of the intermediate prediction samples) to the first bit depth, then, the weighted prediction can be applied, and the final prediction samples can be converted to the second bit depth.

[0265] a. In one example, the second bit depth is the same as the input bit depth of the current color component.

[0266] b. In one example, in the conversion between different bit depths, right shift (e.g., converting a sample from a higher bit depth to a lower bit depth) or left shift (e.g., converting a sample from a lower bit depth to a higher bit depth) can be applied.

[0267] i. Alternatively, in addition, an offset can be added before the right shift or the left shift.

[0268] c. In one example, the first bit depth is the same as the bit depth of the intermediate prediction samples. The weighted sample prediction of the BCW can be derived as:

[0269] pbSamples[x][y] = Clip3(0, (1 « bitDepth) - 1, (w0 * predSamplesL0[x][y] + w1 * predSamplesL1[x][y] + offset3) » (shiftl + 3), where shiftl is set equal to Max(2, 14 - bitDepth) and the variable offset3 is set equal to 1 « (shiftl + 2).

[0270] d. In one example, the first bit depth is the same as the input bit depth of the current color component. The weighted sample prediction of the BCW can be derived as:

[0271] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( w0 * ( ( predSamplesL0[ x ][ y ] + offset1 ) » shift1 ) + w1 * ( ( predSamplesL1[ x ][ y ] + offset1 ) » shift1 ) + 4 ) » 3 ), where shift1 is set equal to Max( 2, 14 - bitDepth ), and variable offset1 is set equal to 1 « ( shift1 - 1 ).

[0272] MMVD range

[0273] 7. In one example, the Merge motion vector difference can be clipped to the same range as the motion vector.

[0274] a. In one example, the Merge motion vector difference can be clipped to 18 bits, e.g., [-2 17 , 2 17 –1], which is the same as the motion vector range in VVC.

[0275] b. In one example, the Merge motion vector difference can be clipped to [-2 17 +1, 2 17 –1].

[0276] c. In one example, the Merge motion vector difference can not be clipped.

[0277] i. For example, the result of the motion vector after adding the Merge motion vector difference to the motion vector predictor candidate is clipped to 18 bits.

[0278] Signaling of cu_skip_flag

[0279] 8. Depending on the size of the coded block, an indication (e.g., cu_skip_flag) can be conditionally signaled whether the CU / PU / block is coded in skip mode.

[0280] a. In one example, the indication (e.g., cu_skip_flag) can be signaled when the current slice type is I slice and sps_ibc_enabled_flag is equal to true and both the block width and the block height are smaller than or equal to N (N is an integer). For example, N = 64.

[0281] b. In one example, the indication (e.g., cu_skip_flag) can be signaled when the current block is coded in IBC mode when both the block width and the block height are smaller than or equal to N (N is an integer). For example, N = 64.

[0282] Coding tool for chroma component

[0283] 9. Whether a coding tool X (e.g., X is TMVP / ATMVP / BCW / MMVD / PDPC) can be applied to a block of a first color component can depend on whether it is applied to one or more corresponding blocks in a second color component.

[0284] a. In one example, the use of coding tool X for a first color component (e.g., chroma) block can be disabled when the coding tool is applied to a corresponding second color component (e.g., luma) block.

[0285] b. In one example, the use of coding tool X for a first color component (e.g., chroma) block can be disabled when a different coding tool Y (where Y is different from X) is applied to a corresponding second color component (e.g., luma) block.

[0286] c. In one example, a message (e.g., a flag or an index) can be conditionally signaled to indicate whether coding tool X is applied to a first color component of a block. The condition can be defined as whether it is applied to a corresponding second color component block. Alternatively, in addition, it is not applied to a first component of a block without signaling if it is not applied to a corresponding second color component block.

[0287] i. In one example, coding tool X can be applied differently to different color components.

[0288] 1) How to apply coding tool X on luma component and chroma component respectively can be signaled.

[0289] d. In one example, the first color component is a chroma component and the second color component is a luma component.

[0290] e. In one example, the first color component is one chroma color component and the second color component is another chroma color component.

[0291] f. In one example, the first color component is a luma color component and the second color component is a chroma color component.

[0292] g. In the above discussion, “corresponding second color component block” can refer to a second color component block that includes at least one “corresponding sample” of the first color component block.

[0293] i. In one example, the first color component is a chroma component and the second color component is a luma component.

[0294] ii. Sample positions can be scaled according to the color format (e.g., 4:4:4 or 4:2:0). Assuming the top-left position of the chroma block is (x0, y0), and the width and height of the chroma block are W and H, all of these sample positions are scaled to luma sample units.

[0295] iii. In one example, the corresponding sample can be at (x0, y0);

[0296] iv. In one example, the corresponding sample can be at (x0 + W - 1, y0 + H - 1);

[0297] v. In one example, the corresponding sample can be at (x0 + W / 2 - 1, y0 + H / 2 - 1);

[0298] vi. In one example, the corresponding sample can be at (x0 + W / 2, y0 + H / 2);

[0299] vii. In one example, the corresponding sample can be at (x0 + W / 2, y0 + H / 2 - 1);

[0300] viii. In one example, the corresponding sample can be at (x0 + W / 2 - 1, y0 + H / 2);

[0301] h. In the above discussion, “chroma component” can refer to “one or more chroma components”.

[0302] 10. It is proposed that the position-dependent intra prediction sample filtering process (also known as PDPC) can be disabled for some chroma components when coding the collocated luma block of a chroma block in some modes.

[0303] a. In one example, this process can be disabled when coding the collocated luma block of a chroma block in MIP (matrix-based intra prediction) mode.

[0304] b. In one example, this process can be disabled when coding the collocated luma block of a chroma block in MRL (multi-reference line) mode.

[0305] 11. The indication of whether to use the optional half-pel interpolation filter can be set to false when the CU / PU / block has MV components only with higher than half-pel precision (e.g., ¼ pel, 1 / 8 pel, etc.). That is, the default half-pel interpolation filter can be used instead of the alternative half-pel interpolation filter.

[0306] a. In one example, this indication can be set to false in MMVD mode if the reconstructed MV has MV components only with higher than half-pel precision.

[0307] b. In one example, for a pair-wise Merge candidate, this indication can be set equal to false if it has only MV components with higher precision than half-pel.

[0308] c. In one example, when the reconstructed bi-predictive motion information is converted to uni-predictive motion information with N or more MV components with higher precision than half-pel (e.g., applied to small blocks such as 4x8 blocks or / and 8x4 blocks), this indication can be set equal to false.

[0309] d. In one example, the indication set to false can be stored and used for subsequently coded CUs / PUs / blocks.

[0310] 12. When a CU / PU / block has N (N is an integer, e.g., N=l) or more MV components (including horizontal and vertical components) with higher precision than half-pel (e.g., ¼-pel, 1 / 8-pel, etc.), an indication of whether to use an alternative half-pel interpolation filter can be set equal to false. That is, the default half-pel interpolation filter can be used instead of the alternative half-pel interpolation filter.

[0311] a. In one example, if the reconstructed MV has N or more MV components with higher precision than half-pel, this indication can be set equal to false in MMVD mode.

[0312] b. In one example, if a pair-wise Merge candidate has N or more MV components with higher precision than half-pel, this indication can be set equal to false.

[0313] c. In one example, when the reconstructed bi-predictive motion information is converted to uni-predictive motion information with N or more MV components with higher precision than half-pel precision (e.g., applied to small blocks such as 4x8 blocks or / and 8x4 blocks), this indication can be set equal to false.

[0314] d. In one example, N can depend on whether the CU / PU / block is uni-predicted or bi-predicted.

[0315] i. For example, a larger N can be used for a bi-predicted CU / PU / block than for a uni-predicted CU / PU / block.

[0316] ii. For example, the same N can be used for both uni-predicted and bi-predicted CU / PU / blocks.

[0317] e. In one example, the indication set equal to false can be stored and used for subsequently coded CUs / PUs / blocks.

[0318] 13. In some cases, the indication of whether to use the optional half-pel interpolation filter can be always set equal to false. That is, in these cases, the default half-pel interpolation filter can always be used.

[0319] a. In one example, in MMVD mode, this indication can always be set equal to false.

[0320] b. In one example, in MMVD mode, this indication can always be set equal to false when some specific MVDs are selected.

[0321] i. For example, if MVDs with ¼ pel precision are selected, this indication can be set equal to false.

[0322] c. In one example, for paired Merge candidates, this indication can always be set equal to false.

[0323] d. In one example, when the reconstructed bi-predictive motion information is converted to uni-predictive motion information (e.g., applied to small blocks, like 4x8 blocks or / and 8x4 blocks), this indication can always be set equal to false.

[0324] e. In one example, the indication set equal to false can be stored and used for subsequent coded CUs / PUs / blocks.

[0325] 14. It is proposed that the optional half-pel interpolation filter can be used in TPM mode.

[0326] a. In one example, the indication of the optional half-pel interpolation filter in TPM mode can be inherited from the Merge candidate.

[0327] i. In one example, the indication of the optional half-pel interpolation filter can be inherited from one or more spatial candidates, and / or TMVP candidate, and / or HMVP candidate and / or paired candidate.

[0328] 1) In one example, the indication of the optional half-pel interpolation filter can be derived from one of the spatial candidates (e.g., the first spatial candidate) of the TMVP candidate.

[0329] 2) Let hPelIf1 and hPelIf2 denote the indication of the first and second candidate in the paired candidate. In one example, when the indication of the optional half-pel interpolation filter is inherited from the paired candidate, it can depend on hPelIf1 or / and hPelIf2.

[0330] a) In one example, the indication of the optional half-pel interpolation filter is set equal to true.

[0331] b) In one example, the indication of the optional half-pel interpolation filter is set equal to false.

[0332] c) In one example, the indication of the optional half-pel interpolation filter is set equal to hPelIf 1.

[0333] d) In one example, the indication of the optional half-pel interpolation filter is set equal to hPelIf 2.

[0334] e) In one example, the indication of the optional half-pel interpolation filter is set equal to (hPelIf 1 && hPelIf 2).

[0335] f) In one example, the indication of the optional half-pel interpolation filter is set equal to (hPelIf 1 || hPelIf 2).

[0336] ii. In one example, the indication of the optional half-pel interpolation filter in TPM mode can be set equal to true.

[0337] b. In one example, the optional half-pel interpolation filter can be used in the process of motion compensation for one partition or two partitions in TPM mode.

[0338] i. In one example, the optional half-pel interpolation filter can be used for partition 1.

[0339] ii. In one example, the optional half-pel interpolation filter can be used for partition 2.

[0340] iii. In one example, the optional half-pel interpolation filter can be used for both partition 1 and partition 2.

[0341] c. In one example, the indication of whether to use the optional half-pel interpolation filter in TPM mode can be stored with the motion field. Denote hPelIfPart 1 and hPelIfPart 2 as the indication of the half-pel interpolation filter for partition 1 and partition 2 in TPM mode.

[0342] i. In one example, the same indication of whether to use the optional half-pel interpolation filter in TPM mode can be stored for all 4x4 units.

[0343] 1) In one example, the indication of whether to use the optional half-pel interpolation filter is set equal to false during the process of motion field storage.

[0344] 2) In one example, the indication of whether to use the optional half-pel interpolation filter is set equal to (hPelIfPart 1 && hPelIfPart 2) during the process of motion field storage.

[0345] 3) In one example, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in the weighted region during the process of motion field storage is set equal to (hPelIfPartl || hPelIfPart2).

[0346] ii. In one example, different indications of whether the optional half-pel interpolation filter is used in TPM mode can be stored for 4x4 units in different partitions (e.g., partition 1, partition 2, or the weighted region).

[0347] 1) In one example, for X replaced by 1 or 2, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in partition X during the process of motion field storage is set equal to hPelIfPartX.

[0348] 2) In one example, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in the weighted region is set equal to (hPelIfPartl && hPelIfPart2).

[0349] 3) In one example, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in the weighted region is set equal to (hPelIfPartl || hPelIfPart2).

[0350] 4) In one example, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in the weighted region is set equal to hPelIfPartl.

[0351] 5) In one example, an indication of whether the optional half-pel interpolation filter is used for 4x4 units in the weighted region is set equal to hPelIfPart2.

[0352] 15. In one example, one or more methods disclosed in bullet 13 can be used for the indication of BCW (also referred to as the generalized bi-prediction (GBi) index).

[0353] 16. The coding tool of whether to enable or disable TMVP candidates can depend on the information of all or part of the motion candidates (named the selected motion candidates) in the Merge list before adding the TMVP candidates.

[0354] a. In one example, the selected motion candidates can be those spatial Merge candidates;

[0355] b. In one example, the selected motion candidates can be the first spatial Merge candidates;

[0356] i. In one example, an indication of whether the optional half-pel interpolation filter is used for TMVP candidates can be set equal to the indication of the first spatial Merge candidates.

[0357] ii. In one example, the BCW index of the TMVP candidate can be set equal to the BCW index of the first spatial Merge candidate.

[0358] iii. In one example, the first spatial Merge candidate can be a left spatial Merge candidate.

[0359] c. In one example, the indication of whether to use the optional half-pel interpolation filter and / or the BCW index can depend on information associated with the selected motion candidate.

[0360] i. In one example, if there are more candidates than remaining candidates, where the indication of whether to use the optional half-pel interpolation filter is equal to 1, then for the TMVP candidate, the indication of whether to use the optional half-pel interpolation filter can be set to 1 (or 0).

[0361] 17. Whether to enable or disable the coding tool of SbTMVP candidate can depend on information of the first spatial

[0362] Merge candidate.

[0363] a. In one example, the indication of whether the optional half-pel interpolation filter is used for the SbTMVP candidate can be set equal to the indication of the first spatial Merge candidate.

[0364] b. In one example, the BCW index of the SbTMVP candidate can be set equal to the BCW index of the first spatial Merge candidate.

[0365] c. In one example, the first spatial Merge candidate can be a left spatial Merge candidate.

[0366] 18. The indication of whether the optional half-pel interpolation filter is used for a block using constructed affine Merge mode can be set equal to the indication of the MV in the neighboring block to generate the control point MV (CPMV).

[0367] a. In one example, the MV in the neighboring block can be in the top-left corner to generate the CPMV.

[0368] b. In one example, the MV in the neighboring block can be in the top-right corner to generate the CPMV.

[0369] c. In one example, the MV in the neighboring block can be in the bottom-left corner to generate the CPMV.

[0370] 19. The indication of whether the optional half-pel interpolation filter is used for a block using affine Merge mode inherited from a neighboring block can be inherited from the neighboring block.

[0371] 20. In one example, if the indication of whether two merge candidates use an optional half-pel interpolation filter is different, the two merge candidates are considered different when compared in the merge candidate construction process.

[0372] Overall assertion

[0373] 21. It can be signaled in sequence level / picture level / slice level / tile group level, e.g., sequence header / picture header / SPS / VPS / DPS / PPS / APS / slice header / tile group header, whether and / or how to apply the disclosed methods above.

[0374] The above examples can be incorporated in the context of the following methods (e.g., methods 800, 900, 1000, 1100, 1200, and 1300), which can be implemented at a video decoder or a video encoder.

[0375] Figure 8 A flowchart of an example method of video processing is shown. The method 800 includes, at step 810, determining availability of one or more collocated motion vectors based on a prediction mode of a collocated video block relative to the current video block.

[0376] The method 800 includes, at step 820, performing a conversion between the current block and a bitstream representation of the current block based on the one or more collocated motion vectors, the indication of the prediction mode including one bit indicating whether the current video block is coded with an inter mode or a non-inter mode.

[0377] Figure 9 A flowchart of an example method of video processing is shown. The method 900 includes, at step 910, determining, for a conversion between a coded representation of a video block and the video block, a type of a collocated video block of the video block, the type taking only one of two possible values.

[0378] The method 900 includes, at step 920, performing the conversion based on the determining.

[0379] Figure 10 A flowchart of an example method of video processing is shown. The method 1000 includes, at step 1010, deriving prediction samples of a current block based on a first weight table associated with a bi-prediction with CU-level weights (BCW) process, the first weight table being asymmetric.

[0380] The method 1000 includes, at step 1020, performing a conversion between the current block and a bitstream representation of the current block based on the prediction samples.

[0381] Figure 11A flowchart illustrating an exemplary method of video processing is shown. The method 1100 includes, at step 1110, determining, based on a dimension of a current video block, selective signaling of an indication of skip mode coding of the current video block in a bitstream representation of the current video block.

[0382] The method 1100 includes, at step 1120, based on the determining, performing a conversion between the current block and a bitstream representation of the current block.

[0383] Figure 12 A flowchart illustrating an exemplary method of video processing is shown. The method 1200 includes, at step 1210, determining, based on an application of a first coding tool to one or more blocks in a first color component of a current video block, selective application of a second coding tool to at least one block of a second color component of the current video block.

[0384] The method 1200 includes, at step 1220, based on the determining, performing a conversion between the current block and a bitstream representation of the current block.

[0385] Figure 13 A flowchart illustrating an exemplary method of video processing is shown. The method 1300 includes, at step 1310, determining, based on a precision of a motion vector in a current video block, selective signaling of an indication to use an optional half-pel interpolation filter instead of a default half-pel interpolation filter.

[0386] The method 1300 includes, at step 1320, based on the determining, performing a conversion between the current block and a bitstream representation of the current block.

[0387] Some embodiments of the disclosed technology include making a decision or determination to enable a video processing tool or mode. In an example, when the video processing tool or mode is enabled, an encoder will use or implement the tool or mode in the processing of a video block, but does not necessarily modify the resulting bitstream based on the use of the tool or mode. That is, the conversion from the video block to a bitstream representation of the video will use the video processing tool or mode when enabled based on the decision or determination. In another example, when the video processing tool or mode is enabled, a decoder will process a bitstream knowing that the bitstream has been modified based on the video processing tool or mode. That is, the conversion from a bitstream representation of the video to the video block will be performed using the video processing tool or mode enabled based on the decision or determination.

[0388] Some embodiments of the disclosed technology include making a decision or determination to disable a video processing tool or mode. In an example, when a video processing tool or mode is disabled, an encoder will not use the tool or mode when converting a video block to a bitstream representation of the video. In another example, when a video processing tool or mode is disabled, a decoder will process a bitstream knowing that the bitstream has not been modified using the video processing tool or mode that is disabled based on the decision or determination.

[0389] In this document, the term “video processing” can refer to video encoding, video decoding, video compression, or video decompression. For example, a video compression algorithm can be applied during a conversion from a pixel representation of a video to a corresponding bitstream representation, or vice versa. For example, a bitstream representation of a current video block can correspond to bits that are collocated or scattered in different locations within a bitstream as defined by syntax. For example, a macroblock can be encoded according to transformed and coded error residual values, and can also be encoded using bits in a header and other fields in the bitstream.

[0390] 5. Exemplary embodiments of the disclosed technology

[0391] Changes are highlighted in bold and italics. Deleted text is marked with double brackets (e.g., [[a]] indicates deleted letter “a”).

[0392] 5.1 Embodiment #1

[0393] The working draft specified in JVET-O2001-vE can be changed as follows.

[0394] 8.5.2.12 Derivation process of collocated motion vector

[0395] …

[0396] The variables mvLXCol and availableFlagLXCol are derived as follows:

[0397] - If colCb is coded with an intra prediction mode or a palette prediction mode or an IBC prediction mode, the two components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0398] - Otherwise, the motion vector mvCol, the reference index refIdxCol and the reference list identifier istCol are derived as follows:

[0399] …

[0400] Alternatively, the following can apply:

[0401] The variables mvLXCol and availableFlagLXCol are derived as follows:

[0402] - If colCb is not coded with [[Intra or IBC]] inter prediction mode, both components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0403] - Otherwise, the motion vector mvCol, the reference index refIdxCol and the reference list identifier listCol are derived as follows:

[0404] …

[0405] 5.2 Embodiment #2

[0406] The working draft specified in JVET-O2001-vE can be changed as follows.

[0407] 8.5.1 General decoding process for coding units coded with inter prediction mode

[0408] …

[0409] 3. For xSbIdx = 0..numSbX - 1, ySbIdx = 0..numSbY - 1, the arrays of decoder-side motion vector refined luma and chroma motion vectors

[0410] (refMvLX[xSbIdx][ySbIdx] and refMvCLX[xSbIdx][ySbIdx] with X being 0 and 1) are derived as follows:

[0411] - If dmvrFlag is equal to 1, the derivation process of chroma motion vectors found in subclause 8.5.2.13 is invoked with refMvLX[xSbIdx][ySbIdx] and refIdxLX as inputs and refMvCLX[xSbIdx][ySbIdx] as output, and refMvLX[xSbIdx][ySbIdx] is derived as follows;

[0412] refMvLX[xSbIdx][ySbIdx] = mvLX[xSbIdx][ySbIdx] + dMvLX[xSbIdx][ySbIdx] (8-287)

[0413] refMvLX[xSbIdx][ySbIdx][0] = Clip3(-2 17 ,2 17 -1, refMvLX[xSbIdx][ySbIdx][0]) (8-288)

[0414] refMvLX[ xSbIdx ][ ySbIdx ][ 0 ] = Clip3( -2 17 ,2 17 -1, refMvLX[ xSbIdx ][ ySbIdx ][ 0 ] ) (8-288)

[0415] - Otherwise ( dmvrFlag is equal to 0 ), the following applies:

[0416] refMvLX[ xSbIdx ][ ySbIdx ][ 0 ] = mvLX[ xSbIdx ][ ySbIdx ][ 0 ] (8-289)

[0417] refMvLX[ xSbIdx ][ ySbIdx ][ 1 ] = mvLX[ xSbIdx ][ ySbIdx ][ 1 ] (8-290)

[0418] NOTE - The array refMvLX is stored in MvDmvrLX and used in the collocated motion vector derivation process in clause 8.5.2.12. After the slice is decoded, MvDmvrLX[ xSbIdx ][ ySbIdx ] and the corresponding reference index are all set equal to -1 when the coding block Cb[ xSbIdx ][ ySbIdx ] is coded with IBC prediction mode. The array of non-refined luma motion vectors mvLX is used in the spatial motion vector prediction and deblocking boundary strength derivation processes.

[0419] …

[0420] 8.5.2.12 Derivation process of collocated motion vector

[0421] …

[0422] The variables mvLXCol and availableFlagLXCol are derived as follows:

[0423] - If colCb is coded with intra prediction mode or IBC prediction mode, the two components of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0424] - Otherwise, the motion vector mvCol, the reference index refIdxCol and the reference list identifier listCol are derived as follows:

[0425] if ( predFlagL0Col[ xColCb ][ yColCb ] is equal to 0 and

[0426] predFlagL1Col[ xColCb ][ yColCb ] is equal to 0, both variables of mvLXCol are set equal to 0 and availableFlagLXCol is set equal to 0.

[0427] Otherwise, the following applies:

[0428] - If sbFlag is equal to 0, availableFlagLXCol is set equal to 1 and the following applies:

[0429] - If predFlagL0Col[ xColCb ][ yColCb ] is equal to 0, mvCol, refIdxCol and listCol are set equal to mvL1Col[ xColCb ][ yColCb ], refIdxL1Col[ xColCb ][ yColCb ] and L1, respectively.

[0430] - Otherwise, if predFlagL0Col[ xColCb ][ yColCb ] is set equal to 1 and predFlagL1Col[ xColCb ][ yColCb ] is equal to 0, mvCol, refIdxCol and listCol are set equal to mvL0Col[ xColCb ][ yColCb ], refIdxL0Col[ xColCb ][ yColCb ] and L0, respectively.

[0431] - Otherwise (predFlagL0Col[ xColCb ][ yColCb ] is equal to 1 and

[0432] predFlagL1Col[ xColCb ][ yColCb ] is equal to 1), the following assignments are made:

[0433] - If NoBackwardPredFlag is equal to 1, mvCol, refIdxCol and listCol are set equal to mvLXCol[ xColCb ][ yColCb ], refIdxLXCol[ xColCb ][ yColCb ] and LX, respectively.

[0434] - Otherwise, mvCol, refIdxCol and listCol are set equal to mvLNCol[ xColCb ][ yColCb ], refIdxLNCol[ xColCb ][ yColCb ] and LN, respectively, where N is the value of collocated_from_l0_flag.

[0435] - Otherwise (sbFlag is equal to 1), the following applies:

[0436] - If PredFlagLXCol[ xColCb ][ yColCb ] is equal to 1, mvCol, refldxCol, and listCol are set equal to mvLXCol[ xColCb ][ yColCb ], refldxLXCol[ xColCb ][ yColCb ], and LX, respectively, and availableFlagLXCol is set equal to 1.

[0437] - Otherwise (PredFlagLXCol[ xColCb ][ yColCb ] is equal to 0), the following applies:

[0438] - If NoBackwardPredFlag is equal to 1 and

[0439] PredFlagLYCol[ xColCb ][ yColCb ] is equal to 1, mvCol, refldxCol, and listCol are set equal to mvLYCol[ xColCb ][ yColCb ], refldxLYCol[ xColCb ][ yColCb ], and LY, respectively, where Y is equal to!X, where X is the value of X for which this process is invoked. availableFlagLXCol is set equal to 1.

[0440] - Otherwise, the two components of mvLXCol are set equal to 0 and

[0441] availableFlagLXCol is set equal to 0.

[0442] …

[0443] 5.3 Embodiment #3

[0444] The working draft as specified in JVET-O2001-vE can be changed as follows.

[0445] 8.5.6.6.2 Default weighted sample prediction process

[0446] …

[0447] The variables shiftl, shift2, offsetl, offset2, and offset3 are derived as follows:

[0448] - The variable shiftl is set equal to Max(2, 14 - bitDepth) and the variable shift2 is set equal to Max(3, 15 - bitDepth).

[0449] - The variable offsetl is set equal to 1 « (shiftl - 1).

[0450] - The variable offset2 is set equal to 1 « (shift2 - 1).

[0451] The variable offset3 is set equal to 1 « (shift2 + 1 [[2]]).

[0452] …

[0453] - Otherwise (predFlagL0 is equal to 1 and predFlagL1 is equal to 1), the following applies:

[0454] - If bcwldx is equal to 0 or ciip_flag[ xCb ][ yCb ] is equal to 1, the predicted sample value is derived as follows:

[0455] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( 8 - 823)

[0456] ( predSamplesL0[ x ][ y ] + predSamplesL1[ x ][ y ] + offset2 ) » shift2 )

[0457] - Otherwise (bcwldx is not equal to 0 and ciip_flag[ xCb ][ yCb ] is equal to 0), the following applies:

[0458] - The variable wl is set equal to bcwWLut[ bcwldx ], where bcwWLut[ k ] = { 4, 5, 3, 10, -2}.

[0459] - The variable w0 is set equal to ( 8 - wl ).

[0460] - The predicted sample value is derived as follows.

[0461] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( 8 - 824)

[0462] ( w0 * predSamplesL0[ x ][ y ] + wl * predSamplesL1[ x ][ y ] + offset3 ) » ( shift2 + [[3]]2 )

[0463] …

[0464] Alternatively, the following can apply:

[0465] …

[0466] The variables shiftl, shift2, offsetl, offset2, and offset3 are derived as follows:

[0467] – the variable shift1 is set equal to Max(2, 14 - bitDepth) [[and the variable shift2 is set equal to Max(3, 15 - bitDepth)]].

[0468] – the variable offset1 is set equal to 1 « (shift1 - 1).

[0469] – the variable offset2 is set equal to 1 « (shift1 + [[2 -]] 1).

[0470] The variable offset3 is set equal to 1 « (shift [[2]] 1 + 2).

[0471] …

[0472] – Otherwise (predFlagL0 is equal to 1 and predFlagL1 is equal to 1), the following applies:

[0473] – If bcwIdx is equal to 0 or ciip_flag[ xCb ][ yCb ] is equal to 1, the predicted sample value is derived as follows:

[0474] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( 8 - 823

[0475] ( predSamplesL0[ x ][ y ] + predSamplesL1[ x ][ y ] + offset2 ) > > ( shift1 + 1 ) [[2]]

[0476] – Otherwise (bcwIdx is not equal to 0 and ciip_flag[ xCb ][ yCb ] is equal to 0), the following applies:

[0477] – The variable w1 is set equal to bcwWLut[ bcwIdx ], where bcwWLut[ k ] = { 4, 5, 3, 10, -2}.

[0478] – The variable w0 is set equal to ( 8 - w1 ).

[0479] – The predicted sample value is derived as follows.

[0480] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( 8 - 824

[0481] (w0 * predSamplesL0[ x ][ y ] + w1 * predSamplesL1[ x ][ y ] + offset3 ) » ( shift1 + 3 [[2 + 3]] ) )

[0482] …

[0483] Alternatively, the following can apply:

[0484] …

[0485] The variables shiftl, shift2, offsetl, offset2, and offset3 are derived as follows:

[0486] - The variable shiftl is set equal to Max(2, 14 - bitDepth) and the variable shift2 is set equal to Max(3, 15 - bitDepth).

[0487] - The variable offsetl is set equal to 1 « (shiftl - 1).

[0488] - The variable offset2 is set equal to 1 « (shift2 - 1).

[0489] - [[The variable offset3 is set equal to 1 « (shift2 + 2).]]

[0490] …

[0491] - Otherwise (predFlagLo is equal to 1 and predFlagLl is equal to 1), the following applies:

[0492] - If bcwldx is equal to 0 or ciip_flag[ xCb ][ yCb ] is equal to 1, the prediction sample value is derived as follows:

[0493] pbSamples[ x ][ y ] = Clip3( 0, ( 1 « bitDepth ) - 1, ( 8 - 823

[0494] ( predSamplesL0[ x ][ y ] + predSamplesLl[ x ][ y ] + offset2 ) » shift2 )

[0495] - Otherwise (bcwldx is not equal to 0 and ciip_flag[ xCb ][ yCb ] is equal to 0), the following applies:

[0496] - The variable wl is set equal to bcwWLut[ bcwldx ], where bcwWLut[ k ] = { 4, 5, 3, 10, -2}.

[0497] – The variable w0 is set equal to (8 - w1).

[0498] – The predicted sample values are derived as follows.

[0499] pbSamples[x][y] = Clip3(0, (1 « bitDepth) - 1, (8 - 824)

[0500] (w0 * ((predSamplesL0[x][y] + offset1) » shift1) + w1 * ((predSamplesL1[x][y] + offset1) » shift1) + 4) » (8 [[shift2+3)]])

[0501] …

[0502] 5.4 Embodiment #4

[0503] The working draft specified in JVET-O2001-vE can be changed as follows.

[0504] 8.5.6.6.2 Default weighted sample prediction process

[0505] …

[0506] – Otherwise (bcwldx is not equal to 0 and ciip_flag[xCb][yCb] is equal to 0), the following applies:

[0507] The variable w1 is set equal to bcwWLut[bcwldx], where bcwWLut[k] = {4, 5, 3, 10, 2[[-2]]} / {4, 5, 3, 10, 1} / {4, 3, 5, 10, 2} / {4, 3, 5, 10, 1} / {4, 5, 3, 10, -1}.

[0508] …

[0509] 5.5 Embodiment #5

[0510] The working draft specified in JVET-O2001-vE can be changed as follows.

[0511] 8.5.2.7 Derivation process of merge motion vector difference

[0512] …

[0513] mMvdL1[0] = Clip3(-2 [

[15] ]17 , 2 [

[15] ]17- 1, (distScaleFactor * mMvdL0[ 0 ] + (8 - 394) 128 - (distScaleFactor * mMvdL0[ 0 ] >= 0)) » 8)

[0514] mMvdL1[ 1 ] = Clip3( -2 [

[15] ]17 , 2 [

[15] ]17 - 1, (distScaleFactor * mMvdL0[ 1 ] + (8 - 395) 128 - (distScaleFactor * mMvdL0[ 1 ] >= 0)) » 8)

[0515] …

[0516] mMvdL0[ 0 ] = Clip3( -2 [

[15] ]17 , 2 [

[15] ]17 - 1, (distScaleFactor * mMvdL1[ 0 ] + (8 - 404) 128 - (distScaleFactor * mMvdL1[ 0 ] >= 0)) » 8)

[0517] mMvdL0[ 1 ] = Clip3( -2 [

[15] ]17 , 2 [

[15] ]17 - 1, (distScaleFactor * mMvdL1[ 1 ] + (8 - 405) 128 - (distScaleFactor * mMvdL1[ 1 ] >= 0)) » 8)

[0518] …

[0519] 5.6 Embodiment #6

[0520] The working draft specified in JVET-O2001-vE can be changed as follows.

[0521] 7.3.8.5 Coding unit syntax

[0522] …

[0523]

[0524]

[0525] 5.7 Embodiment #7

[0526] The working draft specified in JVET-O2001-vE can be changed as follows.

[0527] 8.5.1 General decoding process for coding units coded in inter prediction mode The decoding process for coding units coded in inter prediction mode consists of the following sequential steps:

[0528] 1. The variable dmvrFlag is set equal to 0 and the variable hpelIfIdx is set equal to 0.

[0529] 2. The motion vector components and reference indices of the current coding unit are derived as follows:

[0530] …

[0531] - Otherwise, if MergeTriangleFlag[ xCb ][ yCb ] is equal to 1, inter affine flag[ xCb ][ yCb ] and merge subblock flag[ xCb ][ yCb ] are both equal to 0, the derivation process of the triangle motion vector components and reference indices specified in subclause 8.5.4.1 is invoked for luma coding block position ( xCb, yCb ), luma coding block width cbWidth and luma coding block height cbHeight as inputs, and luma motion vectors mvA and mvB, chroma motion vectors mvCA and mvCB, reference indices refldxA and refldxB, and prediction list flags predListFlagA and predListFlagB, and half-sample interpolation filter indices hpelIfIdxA and hpelIfIdxB as outputs.

[0532] …

[0533] 3. For xSbldx = 0..numSbX - 1, ySbldx = 0..numSbY - 1, the arrays of luma and chroma motion vectors after decoder-side motion vector refinement (refMvLX[ xSbldx ][ ySbldx ] and refMvCLX[ xSbldx ][ ySbldx ], where X is 0 and 1) are derived as follows:

[0534] …

[0535] 4. The prediction samples of the current coding unit are derived as follows:

[0536] - If MergeTriangleFlag[ xCb ][ yCb ] is equal to 0, the prediction samples of the current coding unit are derived as follows:

[0537] …

[0538] ​– Otherwise (MergeTriangleFlag[ xCb ][ yCb ] is equal to 1 ), the decoding process for a Triangular Inter block as specified in clause 8.5.7.1 is invoked with luma coding block position ( xCb, yCb ), luma coding block width cbWidth and luma coding block height cbHeight, luma motion vectors mvA and mvB, chroma motion vectors mvCA and mvCB, reference indices refldxA and refldxB, prediction list flags predListFlagA and predListFlagB, and half-pel interpolation filter indices hpelIfIdxA and hpelIfIdxB as inputs, and as output a ( cbWidth ) x ( cbHeight ) array of predicted luma samples predSamples L and two ( cbWidth / SubWidthC ) x ( cbHeight / SubHeightC ) arrays of predicted chroma samples predSamples Cb and predSamples Cr of inter prediction samples ( predSamples ) for each of the chroma components Cb and Cr.

[0539] …

[0540] 8.5.4 Derivation process for triangular motion vector components and reference indices

[0541] 8.5.4.1 General

[0542] Inputs to this process:

[0543] – the luma position ( xCb, yCb ) of the top-left sample of the current luma coding block relative to the top-left luma sample of the current picture,

[0544] – the variable cbWidth specifying the width of the current coding block in luma samples,

[0545] – the variable cbHeight specifying the height of the current coding block in luma samples.

[0546] Outputs of this process are:

[0547] – the luma motion vectors mvA and mvB with 1 / 16 fractional sample accuracy,

[0548] – the chroma motion vectors mvCA and mvCB with 1 / 32 fractional sample accuracy,

[0549] – the reference indices refldxA and refldxB,

[0550] - the prediction list flags predListFlagA and predListFlagB,

[0551] - the half-sample interpolation filter indices hpelIfIdxA and hpelIfIdxB.

[0552] The derivation process of the luma motion vector for the Triangular Merge mode specified in subclause 8.5.4.2 is invoked with the luma position (xCb, yCb) as input, and the output is the luma motion vectors mvA, mvB, the reference indices refIdxA, refIdxB, and the prediction list flags predListFlagA and predListFlagB.

[0553] The derivation process of the chroma motion vector in subclause 8.5.2.13 is invoked with mvA and refIdxA as input, and the output is mvCA.

[0554] The derivation process of the chroma motion vector in subclause 8.5.2.13 is invoked with mvB and refIdxB as input, and the output is mvCB.

[0555] 8.5.4.2 Derivation process of the luma motion vector for the Merge Triangular mode

[0556] This process is invoked only when MergeTriangleFlag[ xCb ][ yCb ] is equal to 1, where ( xCb, yCb ) specifies the top-left sample of the current luma coding block relative to the top-left luma sample of the current picture.

[0557] The inputs to this process are:

[0558] - the luma position ( xCb, yCb ) of the top-left sample of the current luma coding block relative to the top-left luma sample of the current picture,

[0559] - the variable cbWidth specifying the width of the current coding block in luma samples,

[0560] - the variable cbHeight specifying the height of the current coding block in luma samples.

[0561] The outputs of this process are:

[0562] - the luma motion vectors mvA and mvB with 1 / 16 fractional sample accuracy,

[0563] - the reference indices refIdxA and refIdxB,

[0564] - the prediction list flags predListFlagA and predListFlagB,

[0565] - the half-sample interpolation filter indices hpelIfIdxA and hpelIfIdxB.

[0566] The motion vectors mvA and mvB, the reference indices refIdxA and refIdxB, and the prediction list flags predListFlagA and predListFlagB are derived by the following sequence of steps:

[0567] 1. Invoke the derivation process of the luma motion vectors for the Merge mode specified in Subclause 8.5.2.2 with the luma positions (xCb, yCb), the variables cbWidth and cbHeight as inputs and the outputs being mvL0[0][0], mvL1[0][0], the reference indices refIdxL0, refIdxL1, the prediction list usage flags predFlagL0[0][0] and predFlagL1[0][0], the bi-prediction weight index bcwldx, and the merging candidate list mergeCandList.

[0568] 2. Derive the variables m and n being the merge indices for the triangle partitions 0 and 1, respectively, using merge_triangle_idx0[xCb][yCb] and merge_triangle_idx1[xCb][yCb] as follows:

[0569] m = merge_triangle_idx0[xCb][yCb] (8-475)

[0570] n = merge_triangle_idx1[xCb][yCb] + (merge_triangle_idx1[xCb][yCb] >= m)? 1 : 0 (8-476)

[0571] 3. Let refIdxL0M and refIdxL1M, predFlagL0M and predFlagL1M, and mvL0M and mvL1M be the reference indices, the prediction list usage flags, and the motion vectors of the merging candidate M at position m in the merging candidate list mergeCandList (M = mergeCandList[m]).

[0572] 4. The variable X is set equal to (m & 0x01).

[0573] 5. When predFlagLXM is equal to 0, X is set equal to (1 - X).

[0574] 6. The following applies:

[0575] mvA[0] = mvLXM[0] (8-477)

[0576] mvA[1] = mvLXM[1] (8-478)

[0577] refIdxA = refIdxLXM (8-479)

[0578] predListFlagA = X (8-480)

[0579] hpelIfIdxA = hpelIfIdxM

[0580] (8-xxx)

[0581] 7. Let refIdxLON and refIdxL1N, predFlagLON and predFlagL1N, and mvLON and mvL1N be the reference indices, the prediction list usage flags, and the motion vectors of the merging candidate N at position m in the merging candidate list mergeCandList (N = mergeCandList[n]).

[0582] 8. The variable X is set equal to (n & 0x01).

[0583] 9. When predFlagLXN is equal to 0, X is set equal to (1 - X).

[0584] 10. The following applies:

[0585] mvB[0] = mvLXN[0] (8-481)

[0586] mvB[1] = mvLXN[1] (8-482)

[0587] refIdxB = refIdxLXN (8-483)

[0588] predListFlagB = X (8-484)

[0589] hpelIfIdxB = hpelIfIdxN

[0590] (8-xxx)

[0591] 8.5.7 Decoding process of a triangular inter block

[0592] 8.5.7.1 General

[0593] This process is invoked when decoding a coding unit for which MergeTriangleFlag[ xCb ][ yCb ] is equal to 1.

[0594] The input to this process is:

[0595] - the luma position ( xCb, yCb ) of the top-left sample of the current coding block relative to the top-left luma sample of the current picture,

[0596] - a variable cbWidth specifying the width of the current coding block in luma samples,

[0597] - a variable cbHeight specifying the height of the current coding block in luma samples,

[0598] - luma motion vectors mvA and mvB with 1 / 16 fractional sample accuracy,

[0599] - chroma motion vectors mvCA and mvCB,

[0600] - reference indices refIdxA and refIdxB,

[0601] - prediction list flags predListFlagA and predListFlagB,

[0602] - half-pel interpolation filter indices hpelIfIdxA and hpelIfIdxB.

[0603] The output of this process is:

[0604] - an array predSamples of ( cbWidth ) x ( cbHeight ) luma prediction samples, L ,

[0605] - an array predSamples of ( cbWidth / SubWidthC ) x ( cbHeight / SubHeightC ) chroma prediction samples for component Cb, Cb ,

[0606] - an array predSamples of ( cbWidth / SubWidthC ) x ( cbHeight / SubHeightC ) chroma prediction samples for component Cr. Cr .

[0607] Let predSamplesLA L and predSamplesLB Las a (cbWidth) x (cbHeight) array of predicted luma sample values and predSamplesLA Cb , predSamplesLB Cb , predSamplesLA Cr and predSamplesLB Cr as a (cbWidth / SubWidthC) x (cbHeight / SubHeightC) array of predicted chroma sample values.

[0608] predSamples L , predSamples Cb and predSamples Cr are derived by the following sequential steps:

[0609] 1. The following applies for N being each of A and B:

[0610] - the reference picture consisting of two ordered two-dimensional arrays of luma samples refPicLN L and two ordered two-dimensional arrays of chroma samples refPicLN Cb and refPicLN Cr are derived by invoking the process specified in subclause 8.5.6.2, with X set equal to predListFlagN and refIdxX set equal to refIdxN as inputs.

[0611] - the array predSamplesLN L is derived by invoking the fractional sample interpolation process specified in subclause 8.5.6.3, with the luma positions (xCb, yCb), the luma coding block width sbWidth set equal to cbWidth, the luma coding block height sbHeight set equal to cbHeight, the motion vector offset mvOffset set equal to (0, 0), the motion vector mvLX set equal to mvN, and the reference array refPicLX L set equal to refPicLN L , the variable bdofFlag set equal to false, hpelIfIdxN, and the variable cIdx set equal to 0 as inputs.

[0612] - the array predSamplesLN Cbwhere the luma position ( xCb, yCb ), the coded block width sbWidth set equal to cbWidth / SubWidthC, the coded block height sbHeight set equal to cbHeight / SubHeightC, the motion vector offset mvOffset set equal to ( 0, 0 ), the motion vector mvLX set equal to mvCN, and the reference array refPicLX set equal to refPicLN Cb Cb , the variable bdofFlag set equal to false, hpelIfIdxN, and the variable cIdx set equal to 1 as inputs.

[0613] – derive the array predSamplesLN Cr where the luma position ( xCb, yCb ), the coded block width sbWidth set equal to cbWidth / SubWidthC, the coded block height sbHeight set equal to cbHeight / SubHeightC, the motion vector offset mvOffset set equal to ( 0, 0 ), the motion vector mvLX set equal to mvCN, and the reference array refPicLX set equal to refPicLN Cr Cr , the variable bdofFlag set equal to false, hpelIfIdxN, and the variable cIdx set equal to 2 as inputs.

[0614] 2. The split direction of the Merge triangle mode variable triangleDir is set equal to Merge_triangle_split_dir[ xCb ][ yCb ].

[0615] 3. Derive the predicted samples predSamples L [ x L ][ y L ] within the current luma coded block ( where x L = 0..cbWidth - 1 and y L = 0..cbHeight - 1 ) by invoking the weighted sample prediction process of the triangle Merge mode specified in clause 8.5.7.2, where the coded block width nCbW is set equal to cbWidth, the coded block height nCbH is set equal to cbHeight, the sample arrays predSamplesLA L and predSamplesLB L ​​, and the variable triangleDir, and the variable cldx set equal to 0 as inputs.

[0616] 4. The prediction samples predSamples within the current chroma component Cb coding block are derived by invoking the weighted sample prediction process of the Triangular Merge mode specified in subclause 8.5.7.2 Cb [x C ][y C ] (where x C = 0..cbWidth / SubWidthC - 1 and y C = 0..cbHeight / SubHeightC - 1), where the coding block width nCbW set equal to cbWidth / SubWidthC, the coding block height nCbH set equal to cbHeight / SubHeightC, the sample arrays predSamplesLA Cb and predSamplesLB Cb , and the variable triangleDir, and the variable cldx set equal to 0 as inputs.

[0617] 5. The prediction samples predSamples within the current chroma component Cr coding block are derived by invoking the weighted sample prediction process of the Triangular Merge mode specified in subclause 8.5.7.2 Cr [x C ][y C ] (where x C = 0..cbWidth / SubWidthC - 1 and y C = 0..cbHeight / SubHeightC - 1), where the coding block width nCbW set equal to cbWidth / SubWidthC, the coding block height nCbH set equal to cbHeight / SubHeightC, the sample arrays predSamplesLA Cr and predSamplesLB Cr , and the variable triangleDir, and the variable cldx set equal to 2 as inputs.

[0618] 6. The motion vectors of the process to store the Merge triangle mode specified in section 8.5.7.3 are invoked with the luma coded block position (xCb, yCb), the luma coded block width cbWidth, the luma coded block height cbHeight, the split direction triangleDir, the luma motion vectors mvA and mvB, the reference indices refldxA and refldxB, and the prediction list flags predListFlagA and predListFlagB, and the half pel interpolation filter indices hpelIfIdxA and hpelIfIdxB as inputs.

[0619] 8.5.7.3 Storage of motion vectors of the process of the triangle Merge mode

[0620] This process is invoked when decoding a coded unit with MergeTriangleFlag[ xCb ][ yCb ] equal to 1.

[0621] The inputs of this process are:

[0622] - the luma position (xCb, yCb) of the top-left sample of the current coded block relative to the top-left corner luma sample of the current picture,

[0623] - the variable cbWidth specifying the width of the current coded block in luma samples,

[0624] - the variable cbHeight specifying the height of the current coded block in luma samples,

[0625] - the variable triangleDir specifying the split direction,

[0626] - the luma motion vectors with 1 / 16 fractional sample accuracy mvA and mvB,

[0627] - the reference indices refldxA and refldxB,

[0628] - the prediction list flags predListFlagA and predListFlagB [[.]],

[0629] - the half pel interpolation filter indices hpelIfIdxA and hpelIfIdxB.

[0630] The variables numSbX and numSbY specifying the number of 4x4 blocks of the current coded block in horizontal and vertical direction are set equal to numSbX = cbWidth » 2 and numSbY = cbHeight » 2.

[0631] The variable minSb is set equal to Min(numSbX, numSbY) - 1.

[0632] The variable cbRatio is derived as follows:

[0633] cbRatio = (cbWidth > cbHeight)? (cbWidth / cbHeight) : (cbHeight / cbWidth) (8-848)

[0634] For each 4x4 sub-block at sub-block index (xSbldx, ySSbldx), where xSbldx = 0.. numSbX - 1 and ySbldx = 0.. numSbY - 1, the following applies:

[0635] The variables xldx and yldx are derived as follows:

[0636] xldx = (cbWidth > cbHeight)? (xSbldx / cbRatio) : xSbldx (8-849)

[0637] yldx = (cbWidth > cbHeight)? ySbldx : (ySbldx / cbRatio) (8-850)

[0638] The variable sType is derived as follows:

[0639] If triangleDir is equal to 0, the following applies:

[0640] sType = (xldx == yldx)? 2 : ((xldx > yldx)? 0 : 1) (8-851)

[0641] Otherwise (triangleDir is equal to 1), the following applies:

[0642] sType = (xldx + yldx == minSb)? 2 : ((xldx + yldx < minSb)? 0 : 1) (8-852)

[0643] Depending on the value of sType, the following assignments are made:

[0644] If sType is equal to 0, the following applies:

[0645] predFlagL0 = (predListFlagA == 0)? 1 : 0 (8-853)

[0646] predFlagL1 = ( predListFlagA == 0 )? 0 : 1 (8-854)

[0647] refIdxL0 = ( predListFlagA == 0 )? refIdxA : -1 (8-855)

[0648] refIdxL1 = ( predListFlagA == 0 )? -1 : refIdxA (8-856)

[0649] mvL0[ 0 ] = ( predListFlagA == 0 )? mvA[ 0 ] : 0 (8-857)

[0650] mvL0[ 1 ] = ( predListFlagA == 0 )? mvA[ 1 ] : 0 (8-858)

[0651] mvL1[ 0 ] = ( predListFlagA == 0 )? 0 : mvA[ 0 ] (8-859)

[0652] mvL1[ 1 ] = ( predListFlagA == 0 )? 0 : mvA[ 1 ] (8-860)

[0653] hpelIfIdx = hpelIfIdxA (8-xxx)

[0654] - Otherwise, if sType is equal to 1 or ( sType is equal to 2 and predListFlagA + predListFlagB is not equal to 1 ), the following applies:

[0655] predFlagL0 = ( predListFlagB == 0 )? 1 : 0

[0656] (8-861)

[0657] predFlagL1 = ( predListFlagB == 0 )? 0 : 1

[0658] (8-862)

[0659] refIdxL0 = ( predListFlagB == 0 )? refIdxB : -1 (8-863)

[0660] refIdxL1 = ( predListFlagB == 0 )? -1 : refIdxB (8-864)

[0661] mvL0[ 0 ] = ( predListFlagB == 0 )? mvB[ 0 ] : 0 (8-865)

[0662] mvL0[ 1 ] = ( predListFlagB == 0 )? mvB[ 1 ] : 0 (8-866)

[0663] mvL1[ 0 ] = ( predListFlagB == 0 )? 0 : mvB[ 0 ] (8-867)

[0664] mvL1[ 1 ] = ( predListFlagB == 0 )? 0 : mvB[ 1 ] (8-868)

[0665] hpelIfIdx = hpelIfIdxB (8-xxx)

[0666] - Otherwise ( sType is equal to 2 and predListFlagA + predListFlagB is equal to 1 ), the following applies:

[0667] predFlagL0 = 1 (8-869)

[0668] predFlagL1 = 1 (8-870)

[0669] refIdxL0 = ( predListFlagA == 0 )? refIdxA : refIdxB (8-871)

[0670] refIdxL1 = ( predListFlagA == 0 )? refIdxB : refIdxA (8-872)

[0671] mvL0[ 0 ] = ( predListFlagA == 0 )? mvA[ 0 ] : mvB[ 0 ] (8-873)

[0672] mvL0[ 1 ] = ( predListFlagA == 0 )? mvA[ 1 ] : mvB[ 1 ] (8-874)

[0673] mvL1[ 0 ] = ( predListFlagA == 0 )? mvB[ 0 ] : mvA[ 0 ] (8-875)

[0674] mvL1[ 1 ] = ( predListFlagA == 0 )? mvB[ 1 ] : mvA[ 1 ] (8-876)

[0675] hpelIfIdx = hpelIfIdxA && hpelIfIdxB (8-xxx)

[0676] - For x = 0..3 and y = 0..3, the following assignments are made:

[0677] MvL0[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = mvL0 (8-877)

[0678] MvL1[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = mvL1 (8-878)

[0679] RefIdxL0[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = refIdxL0 (8-879)

[0680] RefIdxL1[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = refIdxL1 (8-880)

[0681] PredFlagL0[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = predFlagL0(8-881)

[0682] PredFlagL1[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = predFlagL1(8-882)

[0683] hpelIfIdx[(xSbIdx « 2) + x][(ySbIdx « 2) + y] = hpelIfIdx (8-xxx)

[0684] Figure 14A FIG. 14 is a block diagram of a video processing device 1400. The device 1400 can be used to implement one or more methods described herein. The device 1400 can be embodied in a smartphone, a tablet computer, a computer, an Internet of Things (IoT) receiver, etc. The device 1400 can include one or more processors 1402, one or more memories 1404, and video processing hardware 1406. The processor(s) 1402 can be configured to implement one or more methods described in the present document, including but not limited to methods 800, 900, 1000, 1100, 1200, and 1300. The memory(ies) 1404 can be used for storing data and code used for implementing the methods and techniques described herein. The video processing hardware 1406 can be used to implement, in hardware circuitry, some of the techniques described in the present document.

[0685] Figure 14Bis a block diagram illustrating an example video processing system 1410 in which various techniques disclosed herein can be implemented. Various implementations can include some or all of the components of system 1410. System 1410 can include an input 1412 for receiving video content. The video content can be received in a raw or uncompressed format (e.g., 8 or 10-bit multi-component pixel values) or can be received in a compressed or encoded format. Input 1412 can represent a network interface, a peripheral bus interface, or a storage interface. Examples of network interfaces include wired interfaces such as Ethernet, passive optical networks (PONs), etc., and wireless interfaces such as Wi-Fi or cellular interfaces.

[0686] System 1410 can include a codec component 1414 that can implement various coding or encoding methods described in this document. Codec component 1414 can reduce the average bitrate of video from input 1412 to the output of codec component 1414 to produce a coded representation of the video. Thus, the coding techniques are sometimes referred to as video compression or video transcoding techniques. The output of codec component 1414 can be stored or transmitted via a connected communication, as represented by component 1416. The stored or transmitted bitstream (or encoded) representation of the video received at input 1412 can be used by component 1418 to generate pixel values or displayable video to display interface 1420. The process of generating user-viewable video from a bitstream representation is sometimes referred to as video decompression. Moreover, although certain video processing operations are referred to as “coding” operations or tools, it will be understood that the coding tools or operations are used at an encoder, and corresponding decoding tools or operations that reverse the results of the encoding will be performed by a decoder.

[0687] Examples of peripheral bus interfaces or display interfaces can include Universal Serial Bus (USB) or High Definition Multimedia Interface (HDMI) or Displayport, etc. Examples of storage interfaces include SATA (Serial Advanced Technology Attachment), PCI, IDE interfaces, etc. The techniques described in this document can be embodied in various electronic devices, such as mobile telephones, laptop computers, smartphones, or other devices that are capable of performing digital data processing and / or video display.

[0688] In some embodiments, video coding methods can be implemented using apparatuses implemented on hardware platforms as described with respect to Figure 14A or Figure 14B implementations described herein.

[0689] The following list provides embodiments that can address the technical problems described in this document, among other problems. The first set of clauses describes certain features and aspects of the disclosed technology in the preceding section.

[0690] 1. A method for processing video, comprising: determining availability of one or more collocated motion vectors based on a prediction mode of a collocated video block relative to a current video block; and performing a conversion between the current block and a bitstream representation of the current block based on the one or more collocated motion vectors, wherein an indication of the prediction mode comprises one bit that indicates whether the current video block is coded in an inter mode or a non-inter mode.

[0691] 2. A method for processing video, comprising: determining, for a conversion between a coded representation of a video block and the video block, a type of a collocated video block of the video block, wherein the type takes only one of two possible values; and performing the conversion based on the determination.

[0692] 3. The method of clause 1, wherein the two possible values include a first value that indicates the collocated video block is inter coded, and a second value that indicates the collocated video block is coded using a mode other than inter coding.

[0693] 4. The method of any of clauses 1-3, wherein the determination is the same when the current video block is coded using a palette prediction mode, and when the current video block is coded using an intra prediction mode or an intra block copy (IBC) prediction mode.

[0694] 5. The method of any of clauses 1-3, wherein the one or more collocated motion vectors are determined to be unavailable when the collocated video block is coded using a non-inter prediction mode.

[0695] 6. The method of any of clauses 1-3, wherein the one or more collocated motion vectors are determined to be unavailable and include a default motion vector when the collocated video block is coded using a non-inter prediction mode.

[0696] 7. The method of clause 5 or 6, wherein the non-inter prediction mode is an intra prediction mode, a palette prediction mode, or an intra block copy (IBC) prediction mode.

[0697] 8. The method of any of clauses 1-3, wherein the determination is based on a reference index or a reference list of the collocated video block.

[0698] 9. The method of clause 8, wherein the reference index is a predetermined value.

[0699] 10. The method of clause 8, wherein the reference index does not include a predetermined value.

[0700] 11. The method of clause 9 or 10, wherein the predetermined value is 0.

[0701] 12. A method for video processing, comprising: deriving prediction samples of a current block based on a first weight table associated with a bi-prediction with coding unit (CU) level weights (BCW) process, wherein the first weight table is asymmetric; and performing a conversion between the current block and a bitstream representation of the current block based on the prediction samples.

[0702] 13. The method of clause 12, wherein entries in the first weight table are non-monotonically increasing.

[0703] 14. The method of clause 12, wherein the BCW process is further based on a second weight table different from the first weight table.

[0704] 15. The method of clause 12, wherein deriving the prediction samples comprises: converting intermediate prediction samples to a first bit-depth; applying weights from the first weight table to the intermediate prediction samples to derive the prediction samples; and converting the prediction samples to a second bit-depth.

[0705] 16. The method of clause 15, wherein the second bit-depth is a bit-depth of a color component of the current video block.

[0706] 17. A method for video processing, comprising: making a decision on selective signaling of an indication of skip mode coding of a current video block in a bitstream representation of the current video block based on a size of the current video block; and performing a conversion between the current block and the bitstream representation of the current block based on the decision.

[0707] 18. The method of clause 17, wherein the indication is signaled when it is determined that a slice type including the current video block is an I slice, sps ibc enabled flag is set to true, and a height and a width of the current video block are less than or equal to N.

[0708] 19. The method of clause 17, wherein the indication is signaled when it is determined that the current video block is coded using intra block copy (IBC) mode and a height and a width of the current video block are less than or equal to N.

[0709] 20. The method of clause 18 or 19, wherein N = 64.

[0710] 21. A method for video processing, comprising: making a decision on selectively applying a second coding tool to at least one block of a second color component of a current video block based on applying a first coding tool to one or more blocks in a first color component of the current video block; and performing a conversion between the current block and a bitstream representation of the current block based on the decision.

[0711] 22. The method of clause 21, wherein the second coding tool is applied upon determining that the second coding tool is equal to the first coding tool.

[0712] 23. The method of clause 21, wherein the second coding tool is not applied upon determining that the second coding tool is not equal to the first coding tool.

[0713] 24. The method of clause 21, wherein the decision is further based on an indication in the bitstream representation.

[0714] 25. The method of any of clauses 21-24, wherein the first color component is a luma component and the second color component is a chroma component.

[0715] 26. The method of any of clauses 21-24, wherein the first color component is a first chroma color component and the second color component is a second chroma color component.

[0716] 27. The method of any of clauses 21-26, wherein the first coding tool and the second coding tool are one of temporal motion vector prediction (TMVP), alternative temporal motion vector prediction (ATMVP), bi-prediction with coding unit (CU) level weights (BCW) process, merge mode with motion vector difference (MMVD), or position dependent prediction combination (PDPC) process.

[0717] 28. A method for video processing, comprising: based on a decision of a motion vector in a current video block, making a decision on a selectable signaling of an indication for using an alternative half-pel interpolation filter instead of a default half-pel interpolation filter; and performing a conversion between the current block and a bitstream representation of the current block based on the decision.

[0718] 29. The method of clause 28, wherein the default half-pel interpolation filter is used upon determining that the current video block is coded using merge mode with motion vector difference (MMVD) and a precision of a reconstructed motion vector is less than half-pel.

[0719] 30. The method of any of clauses 1-9, wherein performing the conversion is further based on signaling in a decoder parameter set (DPS), a sequence parameter set (SPS), a picture parameter set (PPS), an adaptation parameter set (APS), a video parameter set (VPS), a sequence header, a picture header, a slice header, or a tile group header.

[0720] 31. The method of any of clauses 1-30, wherein performing the conversion comprises generating the bitstream representation from the current video block.

[0721] 32. The method of any of clauses 1-30, wherein performing the conversion comprises generating the current video block from the bitstream representation.

[0722] 33. A video decoding apparatus comprising a processor configured to implement a method recited in any of clauses 1-32.

[0723] 34. A computer program product having stored thereon non-transitory computer readable medium comprising program code for executing a method recited in any of clauses 1-32.

[0724] The second set of clauses describes particular features and aspects of the technology disclosed in the previous section (e.g., example items 8-13 and 21).

[0725] 1. A method for video processing (e.g., Figure 21A The method 2110 shown), comprising performing (2112) a conversion between a video block of a video and a coded representation of the video, wherein the coded representation conforms to a format rule that specifies to selectively include, in the coded representation, an indication of a skip mode coding of the video block based on a size of the video block, wherein the skip mode coding allows the conversion to be performed without generating or coding a residual of the video block.

[0726] 2. The method of clause 1, wherein the size comprises a height and a width of the video block.

[0727] 3. The method of clause 1, wherein the format rule specifies to selectively include the indication further based on at least one of: a slice type of a slice that includes the video block or sps ibc enabled flag.

[0728] 4. The method of clause 1, wherein the rule specifies that the indication is included in the coded representation if at least one of the following conditions is satisfied: 1) a slice type of a slice that includes the video block belongs to an I-slice, 2) sps ibc enabled flag is set to true, 3) a height and a width of the video block are less than or equal to N, where N is an integer; or 4) the video block is coded using an intra block copy (IBC) mode.

[0729] 5. The method of clause 4, wherein the at least one condition comprises that the slice type belongs to an I-slice, the sps ibc enabled flag is set to true, or the height and the width of the video block are less than or equal to N, where N is an integer.

[0730] 6. The method of clause 4, wherein the at least one condition comprises: the video block is coded using intra block copy (IBC) mode; or a height and a width of the video block are less than or equal to N, where N is an integer.

[0731] 7. The method of any of clauses 4 to 6, wherein N = 64.

[0732] 8. The method of clause 4, wherein the at least one condition does not include a condition corresponding to sps_palette_enabled_flag.

[0733] 9. A method for video processing (e.g., the method 2100 shown in FIG. 21), comprising: for a conversion between a video block of a video and a coded representation of the video, determining (2122) applicability of a particular coding tool to the video block that is a first color component of the video based on whether the particular coding tool is applied to one or more corresponding video blocks that are a second color component of the video; and performing (2124) the conversion based on the determining. Figure 21B

[0734] 10. The method of clause 9, wherein the determining determines to disable the particular coding tool if the particular coding tool is applied to the one or more corresponding video blocks.

[0735] 11. The method of clause 9, wherein the determining determines to disable the particular coding tool if the particular coding tool is different from a coding tool applied to the one or more corresponding video blocks.

[0736] 12. The method of clause 9, wherein a message indicating applicability of the particular coding tool to the video block is selectively signaled based on whether the particular coding tool is applied to the one or more corresponding video blocks.

[0737] 13. The method of clause 9, wherein the determining determines to disable the particular coding tool if the particular coding tool is applied to the one or more corresponding video blocks and without signaling.

[0738] 14. The method of clause 9, wherein the particular coding tool is applied differently to different color components of the video.

[0739] 15. The method of clause 14, wherein how the particular coding tool is applied to a luma component and a chroma component of the video is signaled.

[0740] 16. The method of any of clauses 9 to 15, wherein the first color component is a chroma color component and the second color component is a luma color component.

[0741] ​17. The method as described in any one of Clauses 9 to 15, wherein the first color component is a first chromaticity color component and the second color component is a second chromaticity color component.

[0742] 18. The method as described in any of Clauses 9 to 15, wherein the first color component is a luminance color component and the second color component is a chrominance color component.

[0743] 19. The method as described in any one of clauses 9 to 18, wherein one or more corresponding video blocks cover at least one corresponding sample of the video block.

[0744] 20. The method as described in Clause 19, wherein the position of at least one corresponding sample point is scaled according to the color format of the video.

[0745] 21. The method as described in Clause 19 or 20, wherein at least one corresponding sample point is located at (x0, y0), (x0+W-1, y0+H-1), (x0+W / 2-1, y0+H / 2-1), (x0+W / 2, y0+H / 2), (x0+W / 2, y0+H / 2-1), or (x0+W / 2-1, y0+H / 2), and wherein the upper left position of the video block is (x0, y0), and the width and height of the video block are W and H, respectively.

[0746] 22. The method as described in any one of Clauses 9 to 21, wherein the particular codec tool is one of the following: Temporal Motion Vector Prediction (TMVP), Alternate Temporal Motion Vector Prediction (ATMVP), Bidirectional Prediction (BCW) process with codec unit (CU) level weighting, Merge Mode with Motion Vector Difference (MMVD), or Position-Related Prediction Combination (PDPC) process.

[0747] 23. A method for video processing (e.g., Figure 21C The method shown (2130) includes: for the conversion between a chroma video block and a video codec representation, determining (2132) a position-dependent intra-prediction combination (PDPC) method that is not allowed to be used for encoding and decoding the chroma video block because the corresponding luma block is encoded and decoded using a specific codec mode; and performing (2134) a conversion based on the determination, wherein the PDPC method combines neighboring samples with the prediction signal of the chroma video block to generate a refined prediction signal of the chroma video block.

[0748] 24. The method as described in Clause 23, wherein a particular encoding / decoding mode corresponds to a matrix-based intra-prediction (MIP) mode.

[0749] 25. The method of clause 23, wherein the particular coding mode corresponds to a multiple reference line (MRL) mode.

[0750] 26. A method for video processing, comprising: performing a conversion between a video block of a video and a coded representation of the video, wherein the coded representation conforms to a format rule that specifies a coding condition that the video block satisfies to include an indication set to false that indicates a use of a selectable half-pel interpolation filter instead of a default half-pel interpolation filter.

[0751] 27. The method of clause 26, wherein the default half-pel interpolation filter is used for the conversion if the coded representation includes the indication set to false.

[0752] 28. The method of clause 26, wherein the format rule specifies that the indication is set to false based on a precision of a motion vector in the video block.

[0753] 29. The method of any of clauses 26-28, wherein the format rule specifies that the indication is set to false if the video block is coded using Merge mode with motion vector difference (MMVD) and reconstructed motion information has a motion vector component that is more precise than half-pel.

[0754] 30. The method of any of clauses 26-28, wherein the format rule specifies that the indication is set to false for a paired Merge candidate that has a motion vector component that is more precise than half-pel.

[0755] 31. The method of any of clauses 26-28, wherein the indication is set to false if reconstructed bi-predictive motion information is converted to uni-predictive motion information that has a motion vector component that is more precise than half-pel.

[0756] 32. The method of any of clauses 26-28, wherein the format rule specifies that the indication is always false.

[0757] 33. The method of any of clauses 26-28, wherein the format rule specifies that the indication is always set to false for a video block that is coded using Merge mode with motion vector difference (MMVD).

[0758] 34. The method of any of clauses 26-28, wherein the format rule specifies that the indication is always set to false for a video block that is coded using Merge mode with motion vector difference (MMVD) if a particular motion vector difference is selected for the conversion.

[0759] 35. The method of clause 34, wherein the particular motion vector difference has 1 / 4-pel precision.

[0760] 36. The method of clause 26 or 27, wherein the format rule specifies that the indication is always set to false for a paired Merge candidate.

[0761] 37. The method of clause 26 or 27, wherein the format rule specifies that the indication is always set to false if reconstructed bi-predictive motion information is converted to uni-predictive motion information.

[0762] 38. The method of any of clauses 32 to 37, wherein the format rule is for indicating use of a bi-coding unit level weighting (BCW) process.

[0763] 39. The method of clause 26 or 27, wherein the format rule specifies that the indication is set to false if the video block has at least N motion vector components that are more precise than half-pel precision, where N is an integer.

[0764] 40. The method of clause 39, wherein the format rule specifies that the indication is set to false if the video block is coded using Merge mode with motion vector difference (MMVD) and reconstructed motion information has at least N motion vector components that are more precise than half-pel precision.

[0765] 41. The method of clause 39, wherein the format rule specifies that the indication is set to false for a paired Merge candidate that has at least N motion vector components that are more precise than half-pel precision.

[0766] 42. The method of clause 39, wherein the format rule specifies that the indication is set to false if reconstructed bi-predictive motion information is converted to uni-predictive motion information that has at least N motion vector components that are more precise than half-pel precision.

[0767] 43. The method of any of clauses 39 to 42, wherein N depends on whether the video block is uni-predicted or bi-predicted.

[0768] 44. The method of any of clauses 39 to 42, wherein N is the same regardless of whether the video block is uni-predicted or bi-predicted.

[0769] 45. The method of any of clauses 26 to 44, wherein the indication set to false is stored and used for another video block.

[0770] 46. A method for video processing, comprising performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein a prediction vector of the video block is generated based on a weighted average of prediction vectors of a plurality of partitions of the video block, wherein at least one partition is angularly split, and wherein the rule specifies to use an optional half-pel interpolation filter for interpolating sample values at half-pel positions when determining the prediction vector.

[0771] 47. The method of clause 46, wherein an indication indicating use of the optional half-pel interpolation filter is inherited from a Merge candidate.

[0772] 48. The method of clause 46, wherein an indication indicating use of the optional half-pel interpolation filter is inherited from a spatial candidate, a TMVP (temporal motion vector prediction) candidate, a HMVP (history-based motion vector prediction) candidate, and / or a paired candidate.

[0773] 49. The method of clause 48, wherein when the indication is inherited from a paired candidate depends on hPelIfi and / or hPelIf2, wherein hPelIfi and hPelIf2 are indications of a first candidate and a second candidate, respectively, among the paired candidate.

[0774] 50. The method of clause 46, wherein for a video block coded using a geometric prediction mode, the indication indicating use of the optional half-pel interpolation filter is set to true.

[0775] 51. The method of clause 46, wherein the rule further specifies to use the optional half-pel interpolation filter in a motion compensation process of a single partition or a plurality of partitions.

[0776] 52. The method of clause 46, wherein one or more indications indicating use of the optional half-pel interpolation filter are stored for one or more motion fields during a motion field storage process.

[0777] 53. The method of clause 52, wherein a same indication regarding use of the optional half-pel interpolation filter is stored for all 4x4 units of the video block.

[0778] 54. The method of clause 53, wherein the same indication is set to false, (hPelIfParti && hPelIfPart2), or (hPelIfParti || hPelIfPart2), wherein hPelIfParti and hPelIfPart2 correspond to indications of using the optional half-pel interpolation filter for a first partition and a second partition, respectively, of the video block.

[0779] 55. The method of clause 52, wherein different indications are stored for different partitions of a video block comprising 4x4 units regarding use of the optional half-pel interpolation filter.

[0780] 56. The method of clause 55, wherein the different indications comprise an indication set to hPelIfPartX for some 4x4 units in an X partition of the video block, wherein hPelIfPartX corresponds to an indication regarding use of the optional half-pel interpolation filter for the X partition, and X is 1 or 2.

[0781] 57. The method of clause 55, wherein the different indications comprise an indication set to (hPelIfPartl && hPelIfPart2), (hPelIfPartl || hPelIfPart2), hPelIfPartl, or hPelIfPart2 for some 4x4 units in a weighted region of the video block, wherein hPelIfPartl and hPelIfPart2 correspond to indications regarding use of the optional half-pel interpolation filter for a first partition and a second partition of the video block, respectively.

[0782] 58. A method for video processing, comprising performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein the rule specifies that an indication regarding a coding condition applied to a motion vector prediction candidate to be added to a Merge list is specified based on information associated with one or more motion candidates present in the Merge list.

[0783] 59. The method of clause 58, wherein the motion vector prediction candidate corresponds to a temporal motion vector prediction (TMVP) candidate for predicting motion information of the video block based on motion information of a collocated video block of the video.

[0784] 60. The method of clause 58, wherein the motion vector prediction candidate corresponds to a subblock-based temporal motion vector prediction (SbTMVP) for predicting motion information of subblocks of the video block based on motion information of a collocated video block of the video.

[0785] 61. The method of clause 58 or 59, wherein the one or more motion candidates correspond to one or more spatial Merge candidates.

[0786] 62. The method of clause 59 or 60, wherein the one or more motion candidates comprise a first spatial Merge candidate, and wherein the rule specifies that an indication to use an optional half-pel interpolation filter for the TMVP candidate or the SbTMVP candidate is set equal to an indication to use the optional half-pel interpolation filter for the first spatial Merge candidate.

[0787] 63. The method of clause 59 or 60, wherein the one or more motion candidates comprise a first spatial Merge candidate, and wherein the rule specifies that a bi-prediction coding unit level weighting (BCW) index for the TMVP candidate or the SbTMVP candidate is set equal to a BCW index for the first spatial Merge candidate.

[0788] 64. The method of clause 59 or 60, wherein the one or more candidates comprise a first spatial Merge candidate that is a left spatial Merge candidate.

[0789] 65. The method of clause 59, wherein the rule further specifies that an indication to use an optional half-pel interpolation filter for the TMVP candidate and / or to use a bi-prediction coding unit level weighting (BCW) index for the TMVP candidate is dependent on information associated with the one or more motion candidates.

[0790] 66. A method for video processing (e.g., as shown in FIG. 21), comprising: Figure 21D determining (2142), for a conversion between a video block of a video and a coded representation of the video, a control point motion vector for a control point of the video block coded using an affine Merge mode based on motion information of neighboring blocks of the video block, and performing the conversion based on the determining (2144), wherein the rule specifies that an indication to use an optional half-pel interpolation filter for the video block is set equal to an indication of a motion vector in the neighboring blocks.

[0791] 67. The method of clause 66, wherein the determining determines the control point motion vector for a top-left corner, a top-right corner, or a bottom-left corner of the video block based on the motion vectors in the neighboring blocks.

[0792] 68. A method for video processing, comprising: performing a conversion between a video block of a video and a coded representation of the video according to a rule, wherein the rule specifies that if the video block is coded using an affine Merge mode inherited from neighboring blocks of the video block, an indication to use an optional half-pel interpolation filter for the video block is inherited from the neighboring blocks.

[0793] 69. A method for video processing (e.g., as shown in FIG. 22), comprising: Figure 21EThe illustrated method 2150) includes deriving (2152) motion information for a video block of a video by examining Merge candidates according to a rule during a Merge candidate reconstruction process, and performing a conversion between the video block and a coded representation of the video, wherein the rule specifies that two Merge candidates are considered different during the candidate reconstruction process if an indication of usage of an optional half-pixel interpolation filter for the two Merge candidates being compared is not the same.

[0794] 70. The method of any of clauses 1-69, wherein performing the conversion is further based on signaling in a decoder parameter set (DPS), a sequence parameter set (SPS), a picture parameter set (PPS), an adaptation parameter set (APS), a video parameter set (VPS), a sequence header, a picture header, a slice header, or a tile group header.

[0795] 71. The method of any of clauses 1-70, wherein the conversion comprises encoding the coded representation to a coded representation.

[0796] 72. The method of any of clauses 1-70, wherein the conversion comprises decoding the coded representation to generate a video.

[0797] 73. A video processing apparatus comprising a processor configured to implement a method recited by any one or more of clauses 1-72.

[0798] 74. A computer-readable medium storing program code that, when executed, causes a processor to implement a method recited by any one or more of clauses 1-72.

[0799] 75. A computer-readable medium storing a coded representation or bitstream representation generated according to any of the methods described above.

[0800] From the foregoing, it will be appreciated that, for purposes of illustration, the specific embodiments of the presently disclosed technology have been described herein in great detail, including specific capital equipment, procedures, and techniques. Various modifications are possible, however, without departing from the scope of the present invention. The presently disclosed technology should, therefore, be considered in all respects as illustrative and not restrictive, the scope of the invention being indicated by the appended claims rather than by the foregoing description.

[0801] Implementations of the subject matter and the functional operations described in this patent document can be implemented in various systems, digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. Implementations of the subject matter described in this specification can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a tangible and non-transitory computer readable medium for execution by, or to control the operation of, data processing apparatus. The computer readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a composition of matter effecting a machine-readable propagated signal, or a combination of one or more of them. The term“data processing apparatus” or“data processing device” encompasses all apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. The apparatus can also include, in addition to hardware, code that creates an execution environment for the computer program in question, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

[0802] A computer program (also known as a program, software, software application, script, or code) can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub programs, or portions of code). A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and are interconnected by a communication network.

[0803] The processes and logic flows described in this specification can be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by special purpose logic circuitry, and the apparatus can also be implemented as special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).

[0804] Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. However, a computer need not have such devices. Computer readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.

[0805] The description herein is intended to be illustrative, and not restrictive. As used herein, the singular "a" and "an" are intended to include the plural forms as well, unless the context clearly indicates otherwise. Additionally, the use of "or" is intended to include "and / or," unless the context clearly indicates otherwise.

[0806] Although this patent document contains many details, these should not be construed as limiting the scope of any invention or of what can be claimed, but as merely describing features that can be specific to certain embodiments of the inventions. Certain features described herein in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features described herein in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable sub-combination. Moreover, although features can be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination and the claimed combination can be directed to a sub-combination or a variation of a sub-combination.

[0807] Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring such order, nor that all illustrated operations be performed, to achieve desirable results. In addition, the separation of various system components in the embodiments described herein should not be understood as requiring such separation in all embodiments.

[0808] Only a few implementations and examples are described and other implementations, enhancements and variations can be made based on what is described and illustrated in this patent document.

Claims

1. A method of video processing, comprising: performing a first conversion between a video block of a video and a coded representation of the video, wherein the coded representation conforms to a format rule that specifies selectively including, in the coded representation, an indication of a skip mode coding of the video block based on a dimension of the video block, wherein the skip mode coding allows the first conversion to be performed without generating or without coding a residual of the video block; wherein the indication is included in the coded representation when a slice type of a slice of the video block is an I-slice, sps ibc enabled flag is set to true, and a height and a width of the video block are less than or equal to N, wherein N is an integer.

2. The method of claim 1, wherein, the dimension includes a height and a width of the video block.

3. The method of claim 1, wherein, N = 64。 4. The method of claim 1, wherein, the condition under which the indication is included in the coded representation does not include a condition corresponding to sps_palette_enabled_flag.

5. The method of claim 1, further comprising: for a second conversion between a video block of the video and a coded representation of the video, determining, based on whether a particular coding tool is applied to one or more corresponding video blocks that are a second color component of the video, an applicability of the particular coding tool to the video block that is a first color component of the video; and and performing the second conversion based on the determining.

6. The method of claim 5, wherein, the determining determines to disable the particular coding tool in a case that the particular coding tool is applied to the one or more corresponding video blocks.

7. The method of claim 5, wherein, the determining determines to disable the particular coding tool in a case that the particular coding tool is different from a coding tool applied to the one or more corresponding video blocks.

8. The method of claim 5, wherein, selectively signaling a message based on whether the particular coding tool is applied to the one or more corresponding video blocks, the message indicating the applicability of the particular coding tool to the video block.

9. The method of claim 5, wherein, the determining determines to disable the particular coding tool in a case that the particular coding tool is applied to the one or more corresponding video blocks without signaling.

10. The method of claim 5, wherein, the particular coding tool is applied differently to different color components of the video.

11. The method of claim 10, wherein, signaling how to apply the particular coding tool to a luma component and a chroma component of the video.

12. The method of any of claims 5-11, wherein, the first color component is a chroma color component and the second color component is a luma color component.

13. The method of any of claims 5-11, wherein, the first color component is a first chroma color component and the second color component is a second chroma color component.

14. The method of any of claims 5-11, wherein, the first color component is a luma color component and the second color component is a chroma color component.

15. The method of claim 5, wherein, the one or more corresponding video blocks cover at least one corresponding sample of the video block.

16. The method of claim 15, wherein, scaling a position of the at least one corresponding sample according to a color format of the video.

17. The method of claim 15 or 16, wherein, The at least one corresponding sample is located at (x0, y0), (x0+W-1, y0+H-1), (x0+W / 2-1, y0+H / 2-1), (x0+W / 2, y0+H / 2), (x0+W / 2, y0+H / 2-1), or (x0+W / 2-1, y0+H / 2), and wherein a top-left position of the video block is (x0, y0) and a width and a height of the video block are W and H, respectively.

18. The method of claim 5, wherein, The particular coding tool is one of: temporal motion vector prediction (TMVP), alternative temporal motion vector prediction (ATMVP), bi-prediction with coding unit (CU) level weighting (BCW) process, merge mode with motion vector differences (MMVD), or position dependent prediction combination (PDPC) process.

19. The method of claim 1, further comprising: for a third conversion between a chroma video block of the video and a coded representation of the video, determining that a position dependent intra prediction combination (PDPC) method is not allowed for a coded chroma video block due to a corresponding luma block being coded using a particular coding mode; and performing the third conversion based on the determining, wherein the PDPC method combines neighboring samples with a prediction signal of the chroma video block to generate a refined prediction signal of the chroma video block.

20. The method of claim 19, wherein, The particular coding mode corresponds to a matrix-based intra prediction (MIP) mode.

21. The method of claim 19, wherein, The particular coding mode corresponds to a multi-reference line (MRL) mode.

22. The method of claim 1, further comprising: performing a fourth conversion between a video block of the video and a coded representation of the video, wherein the coded representation conforms to a format rule, the format rule specifying that a coding condition that a video block satisfies includes an indication set to false, the indication indicating that a default half-pel interpolation filter is used instead of an alternative half-pel interpolation filter.

23. The method of claim 22, wherein, In a case that the coded representation includes the indication set to false, the default half-pel interpolation filter is used for the fourth conversion.

24. The method of claim 22, wherein, The format rule specifies that the indication is set to false based on a precision of a motion vector in the video block.

25. The method of any of claims 22-24, wherein, The format rule specifies that the indication is set to false in a case that the video block is coded using merge mode with motion vector differences (MMVD) and reconstructed motion information has a motion vector component with higher precision than half-pel.

26. The method of any of claims 22-24, wherein, The format rule specifies that the indication is set to false for a paired merge candidate with a motion vector component with higher precision than half-pel.

27. The method of any of claims 22-24, wherein, The format rule specifies that the indication is set to false in a case that reconstructed bi-predictive motion information is converted to uni-predictive motion information with a motion vector component with higher precision than half-pel.

28. The method of any of claims 22-24, wherein, The format rule specifies that the indication is always false.

29. The method of any of claims 22-24, wherein, The format rule specifies that the indication is always set to false for the video block coded using merge mode with motion vector differences (MMVD).

30. The method of any of claims 22-24, wherein, The format rule specifies that the indication is always set to false for the video block coded using Merge mode with motion vector difference (MMVD) in case a particular motion vector difference value is selected for the fourth conversion.

31. The method of claim 30, wherein, The particular motion vector difference value has a precision of 1 / 4 pel.

32. The method of claim 22 or 23, wherein, The format rule specifies that the indication is always set to false for a paired Merge candidate.

33. The method of claim 22 or 23, wherein, The format rule specifies that the indication is always set to false in case reconstructed bi-predictive motion information is converted to uni-predictive motion information.

34. The method of claim 28, wherein, The format rule is for indicating usage of bi-coding unit level weighting (BCW) process.

35. The method of claim 22 or 23, wherein, The format rule specifies that the indication is set to false in case the video block has at least N motion vector components with higher precision than half-pel, where N is an integer.

36. The method of claim 35, wherein, The format rule specifies that the indication is set to false in case the video block is coded using Merge mode with motion vector difference (MMVD) and reconstructed motion information has at least N motion vector components with higher precision than half-pel.

37. The method of claim 35, wherein, The format rule specifies that the indication is set to false for a paired Merge candidate with at least N motion vector components with higher precision than half-pel.

38. The method of claim 35, wherein, The format rule specifies that the indication is set to false in case reconstructed bi-predictive motion information is converted to uni-predictive motion information with at least N motion vector components with higher precision than half-pel.

39. The method of claim 35, wherein, N depends on whether the video block is uni-predicted or bi-predicted.

40. The method of claim 35, wherein, N is the same regardless of whether the video block is uni-predicted or bi-predicted.

41. The method of claim 22, wherein, The indication set to false is stored and used for another video block.

42. The method of claim 1, further comprising: performing a fifth conversion between a video block of the video and a coded representation of the video according to a rule, wherein a prediction vector of the video block is generated based on a weighted average of prediction vectors of a plurality of partitions of the video block, wherein at least one partition is angularly partitioned, and wherein the rule specifies that a sample value at a half-pel position is interpolated when determining the prediction vector using an optional half-pel interpolation filter.

43. The method of claim 42, wherein, an indication indicating usage of the optional half-pel interpolation filter is inherited from a Merge candidate.

44. The method of claim 42, wherein, the indication indicating usage of the optional half-pel interpolation filter is inherited from a spatial candidate, a TMVP (temporal motion vector prediction) candidate, a HMVP (history-based motion vector prediction) candidate, and / or a paired candidate.

45. The method of claim 44, wherein, when the indication is inherited from the paired candidate depends on hPelIf1 and / or hPelIf2, wherein hPelIf1 and hPelIf2 are indications of a first candidate and a second candidate among the paired candidate, respectively.

46. The method of claim 42, wherein, the indication indicating usage of the optional half-pel interpolation filter is set to true for the video block coded using a geometric prediction mode.

47. The method of claim 42, wherein, the rule further specifies that the optional half-pel interpolation filter is used in a motion compensation process of a single partition or a plurality of partitions.

48. The method of claim 42, wherein, During field storage, one or more indications are stored for one or more fields indicating use of the optional half-pixel interpolation filter.

49. The method of claim 48, wherein, The same indication is stored for all 4x4 units of the video block regarding use of the optional half-pixel interpolation filter.

50. The method of claim 49, wherein, The same indication is set to false, (hPelIfPartl && hPelIfPart2), or (hPelIfPartl || hPelIfPart2), where hPelIfPartl and hPelIfPart2 correspond to indications of use of the optional half-pixel interpolation filter for a first partition and a second partition of the video block, respectively.

51. The method of claim 48, wherein, Different indications are stored for different partitions of the video block including 4x4 units regarding use of the optional half-pixel interpolation filter.

52. The method of claim 51, wherein, The different indications include indications set to hPelIfPartX for some 4x4 units in an Xth partition of the video block, where hPelIfPartX corresponds to an indication of use of the optional half-pixel interpolation filter for the Xth partition, and X is 1 or 2.

53. The method of claim 51, wherein, The different indications include indications set to (hPelIfPartl && hPelIfPart2), (hPelIfPartl || hPelIfPart2), hPelIfPartl, or hPelIfPart2 for some 4x4 units in a weighted region of the video block, where hPelIfPartl and hPelIfPart2 correspond to indications of use of the optional half-pixel interpolation filter for a first partition and a second partition of the video block, respectively.

54. The method of claim 1, further comprising: performing a sixth conversion between a video block of a video and a coded representation of the video according to a rule, wherein the rule specifies an indication of a coding condition applied to a motion vector prediction candidate to be added to a Merge list based on information associated with one or more motion candidates present in the Merge list.

55. The method of claim 54, wherein, The motion vector prediction candidate corresponds to a temporal motion vector prediction (TMVP) candidate for predicting motion information of the video block based on motion information of a collocated video block of the video.

56. The method of claim 54, wherein, The motion vector prediction candidate corresponds to a sub-block based temporal motion vector prediction (SbTMVP) for predicting motion information of sub-blocks of the video block based on motion information of collocated video blocks of the video block.

57. The method of claim 54 or 55, wherein, The one or more motion candidates correspond to one or more spatial Merge candidates.

58. The method of claim 55 or 56, wherein, The one or more motion candidates include a first spatial domain Merge candidate, and wherein the rule specifies that the indication of using an optional half-pel interpolation filter for a temporal motion vector prediction (TMVP) candidate or a sub-block based temporal motion vector prediction (SbTMVP) candidate is set equal to an indication of using the optional half-pel interpolation filter for the first spatial domain Merge candidate.

59. The method of claim 55 or 56, wherein, The one or more motion candidates include a first spatial domain Merge candidate, and wherein the rule specifies that a bi-prediction unit level weighting (BCW) index of a temporal motion vector prediction (TMVP) candidate or a sub-block based temporal motion vector prediction (SbTMVP) candidate is set equal to a BCW index of the first spatial domain Merge candidate.

60. The method of claim 55 or 56, wherein, The one or more motion candidates include a first spatial domain Merge candidate that is a left spatial domain Merge candidate.

61. The method of claim 55, wherein, The rule further specifies that the indication of using an optional half-pel interpolation filter for the TMVP candidate and / or using a bi-prediction unit level weighting (BCW) index for the TMVP candidate depends on the information associated with the one or more motion candidates.

62. The method of claim 1, further comprising: determining, for a seventh conversion between a video block of a video and a coded representation of the video, control point motion vectors of control points of the video block coded using an affine Merge mode based on motion information of neighboring blocks of the video block according to a rule; and performing the seventh conversion based on the determination, wherein the rule specifies that an indication of using an optional half-pel interpolation filter for the video block is set equal to an indication of motion vectors in the neighboring blocks.

63. The method of claim 62, wherein, The determination determines the control point motion vectors located at a top-left corner, a top-right corner, or a bottom-left corner of the video block based on the motion vectors in the neighboring blocks.

64. The method of claim 1, further comprising: performing an eighth conversion between a video block of the video and a coded representation of the video according to a rule, wherein the rule specifies that an indication of using an optional half-pel interpolation filter for the video block is inherited from neighboring blocks of the video block in case the video block is coded using an affine Merge mode inherited from the neighboring blocks.

65. The method of claim 1, further comprising: deriving motion information of a video block of the video by examining Merge candidates during a Merge candidate construction process according to a rule; and, performing a ninth conversion between the video block and a coded representation of the video, wherein the rule specifies that two Merge candidates compared are considered different during the Merge candidate construction process in case an indication of usage of an optional half-pel interpolation filter of the two Merge candidates is not the same.

66. The method of claim 1, wherein, The performing the first conversion is further based on signaling in a decoder parameter set (DPS), a sequence parameter set (SPS), a picture parameter set (PPS), an adaptation parameter set (APS), a video parameter set (VPS), a sequence header, a picture header, a slice header, or a tile group header.

67. The method of claim 1, wherein, The first conversion comprises encoding the video into the coded representation.

68. The method of claim 1, wherein, The first conversion comprises decoding the coded representation to generate the video.

69. A video processing apparatus comprising a processor configured to implement a method recited in any of claims 1-68.

70. A computer readable medium storing program code that, when executed, causes a processor to implement a method recited in any of claims 1-68.

Images