Chroma deblocking tuning for video coding and decoding

Abstract

Describes chroma deblocking tuning for video encoding and decoding. In an exemplary aspect, a method for video processing includes a conversion between a first color component of a current block of a video and a bitstream representation of the first color component of the current block of the video, determining one or more deblocking parameters associated with the first color component involved in a deblocking filter process based on one or more quantization parameters (QPs) associated with a second color component of the current block of the video; and performing the conversion based on the determined deblocking parameters.

Description

[0001] Cross - reference to related applications

[0002] This application is filed to claim the priority and benefits of International Patent Application No. PCT / CN2019 / 103969, filed on September 2, 2019, in a timely manner in accordance with the provisions of applicable patent laws and / or the Paris Convention. The entire disclosure of International Patent Application No. PCT / CN2019 / 103969 is incorporated by reference as part of the disclosure of this application. Technical field

[0003] This patent document relates to video coding and decoding technologies, devices, and systems. Background art

[0004] Currently, efforts are being made to improve the performance of current video codec technologies to provide a better compression ratio, or to provide video encoding and decoding schemes that allow for lower complexity or parallel implementation. Industry experts have recently proposed several new video coding and decoding tools, which are currently being tested to determine their effectiveness. Summary of the invention

[0005] Devices, systems, and methods related to digital video coding and decoding are described, specifically, devices, systems, and methods related to the management of motion vectors. The described methods can be applied to existing video coding standards (e.g., High Efficiency Video Coding (HEVC) or Versatile Video Coding) and future video coding standards or video codecs.

[0006] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes performing a conversion between a current video unit and a bit - stream representation of the current video unit, wherein during the conversion, a decision is made to selectively apply the same filtering operation to multiple color components of the current video unit, and the decision to apply the filtering is based on a binary value that satisfies at least one condition.

[0007] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes deriving at least one decision result for the conversion between a video processing unit of a video and a bit - stream representation of the video processing unit, the at least one decision result being associated with a decision in a chrominance de - blocking filter decision process for the video processing unit; applying the same decision result from the at least one decision result to all chrominance components of the video processing unit; and performing the conversion based on the same decision result.

[0008] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes a conversion between a video processing unit of a video and a bitstream representation of the video processing unit, deriving at least one deblocking filter associated with a chrominance deblocking filter process of the video processing unit; for all chrominance components of the video processing unit, applying the same deblocking filter from the at least one deblocking filter; and performing the conversion based on the same deblocking filter.

[0009] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes a conversion between a video processing unit of a video and a bitstream representation of the video processing unit, deriving deblocking parameters associated with a chrominance deblocking filter decision process and / or a chrominance deblocking filter process of the video processing unit; for all chrominance components of the video processing unit, applying the same deblocking parameters from the deblocking parameters; and performing the conversion based on the same deblocking parameters.

[0010] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes a conversion between a first color component of a current block of a video and a bitstream representation of the first color component of the current block of the video, determining one or more deblocking parameters of the first color component involved in a deblocking filter process based on one or more quantization parameters (QP) associated with a second color component of the current block of the video; and performing the conversion based on the determined deblocking parameters.

[0011] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes a conversion between a first chrominance component of a current block of a video and a bitstream representation of the first chrominance component of the current block of the video, applying one or more processes or parameters to a chrominance deblocking process of the first chrominance component to modify the chrominance deblocking process of the first chrominance component; and performing the conversion based on the modified chrominance deblocking process.

[0012] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes a conversion between a first color component of a current block of a video and a bitstream representation of the first color component of the current block of the video, determining a deblocking process for the first color component based on corresponding sample values of a second color component of the current block of the video; and performing the conversion based on the determined deblocking process for the first color component.

[0013] In a representative aspect, the disclosed technology can be used to provide a method for video processing. The method includes performing a conversion between a large block of a video and a bitstream representation of the large block of the video, determining a deblocking filter to be executed on a block boundary of the large block based on a deblocking condition and one or more deblocking filter conditions; and performing the conversion based on the determined deblocking filter.

[0014] In addition, in a representative aspect, a device in a video system is disclosed, including a processor and a non-transitory memory having instructions thereon. The instructions, when executed by the processor, cause the processor to implement any one or more of the disclosed methods.

[0015] In addition, a computer program product stored on a non-transitory computer-readable medium is disclosed, including a computer program product including program code for performing any one or more of the disclosed methods.

[0016] The above or other aspects and features of the disclosed technology are described in more detail in the drawings, the specification, and the claims. Description of the Drawings

[0017] Figure 1 An example of the overall processing of the deblocking filter process is shown.

[0018] Figure 2 An example of boundary strength (BS) calculation is shown.

[0019] Figure 3 An example of BS calculation at the boundary of a coding tree unit (CTU) is shown.

[0020] Figure 4 An example of pixels involved in filter on / off decision and filter selection is shown.

[0021] Figure 5 A block diagram showing an example of a hardware platform for implementing visual media decoding or visual media encoding techniques described in this document is shown.

[0022] Figure 6 A flowchart showing an example method for video coding and decoding is shown.

[0023] Figure 7 A flowchart showing an example method for video coding and decoding is shown.

[0024] Figure 8 A flowchart showing an example method for video coding and decoding is shown.

[0025] Figure 9 A flowchart showing an example method for video coding and decoding is shown.

[0026] Figure 10A flowchart showing an example method for video coding and decoding is presented.

[0027] Figure 11 A flowchart showing an example method for video coding and decoding is presented.

[0028] Figure 12 A flowchart showing an example method for video coding and decoding is presented.

[0029] Figure 13 A flowchart showing an example method for video coding and decoding is presented. Detailed implementation

[0030] 1. Video Coding and Decoding in HEVC / H.265

[0031] Video coding and decoding standards have mainly evolved through the development of well-known ITU-T and ISO / IEC standards. ITU-T produced H.261 and H.263, ISO / IEC produced MPEG-1 and MPEG-4 Visual, and the two organizations jointly produced the H.262 / MPEG-2 video, H.264 / MPEG-4 Advanced Video Coding (AVC), and H.265 / HEVC standards. Starting from H.262, video coding and decoding standards are based on a hybrid video coding and decoding structure, where temporal prediction plus transform coding is utilized. To explore future video coding and decoding technologies beyond HEVC, VCEG and MPEG jointly established the Joint Video Exploration Team (JVET) in 2015. Since then, JVET has adopted many new methods and incorporated them into a reference software called the "Joint Exploration Model" (JEM). In April 2018, the Joint Video Experts Team (JVET) between VCEG (Q6 / 16) and ISO / IEC JTC1 SC29 / WG11 (MPEG) was established to strive for a 50% reduction in bitrate for the VVC standard compared to HEVC.

[0032] 2.1 Deblocking Scheme in HEVC

[0033] The deblocking filter process is performed for each CU in the same order as the decoding process. First, the vertical edges are filtered (horizontal filtering), and then the horizontal edges are filtered (vertical filtering). For both the luminance and chrominance components, filtering is applied to determine the 8x8 block boundaries to be filtered. To reduce complexity, the 4x4 block boundaries are not processed.

[0034] Figure 1 The overall processing flow of the deblocking filter process is illustrated. The boundary can have three filtering states: no filtering, weak filtering, and strong filtering. Each filtering decision is based on the boundary strength, Bs, and the thresholds, β and t C .

[0035] 2.1.1 Boundary Decision

[0036] Three types of boundaries can be involved in the filtering process: CU boundary, TU boundary, and PU boundary. Since the CU boundary is always also a TU boundary or a PU boundary, the CU boundary, which is the outer edge of the CU, is always involved in the filtering. When the PU shape is 2NxN (N>4) and the RQT depth is equal to 1, the TU boundary at the 8x8 block grid and the PU boundary between each PU inside the CU are involved in the filtering. An exception is when the PU boundary is inside the TU, in which case the boundary is not filtered.

[0037] 2.1.2 Boundary Strength Calculation

[0038] Generally speaking, the boundary strength (Bs) reflects how strong the filtering needs to be for the boundary. If Bs is large, strong filtering should be considered.

[0039] Let P and Q be defined as the blocks involved in the filtering, where P represents the block on the left (for vertical edge cases) or above (for horizontal edge cases) side of the boundary and Q represents the block on the right (for vertical edge cases) or above (for horizontal edge cases) side of the boundary. Figure 2 The figure illustrates how to calculate the Bs value based on the intra-frame coding / decoding mode, the presence of non-zero transform parameters and motion information, reference pictures, the number of motion vectors, and the motion vector difference.

[0040] The Bs is calculated on a 4x4 block basis but remapped to an 8x8 grid. The maximum value of the two Bs values corresponding to 8 pixels composed of rows in the 4x4 grid is selected as the Bs for the boundary in the 8x8 grid.

[0041] As Figure 3 depicted, to reduce the row buffer memory requirement, the information in every second block (4x4 grid) on the left or above side is reused only for the CTU boundary.

[0042] 2.1.3 β and t C Decision

[0043] Based on the luminance quantization parameters of the P and Q blocks (QP P and QP Q respectively), the thresholds β and t for the filter on / off decision, strong and weak filter selection, and the weak filtering process are derived C . The Q for deriving β and t C is calculated as follows.

[0044] Q = ((QP P + QP Q + 1) >> 1).

[0045] Derive variable β based on Q as shown in Table 1. If Bs is greater than 1, variable t C As specified in Table 1, with Clip3(0, 55, Q + 2) as the input.

[0046] Table 1 - Deriving threshold variables β and t from input Q C

[0047] Q 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 β 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 7 8 <![CDATA[t C > 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 Q 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 β 9 10 11 12 13 14 15 16 17 18 20 22 24 26 28 30 32 34 36 <![CDATA[t C > 1 1 1 1 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 Q 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 β 38 40 42 44 46 48 50 52 54 56 58 60 62 64 64 64 64 64 <![CDATA[t C > 5 5 6 6 7 8 9 9 10 10 11 11 12 12 13 13 14 14

[0048] 2.1.4. Filter on / off decision for four rows

[0049] For four rows as a unit, complete the filter on / off decision. Figure 4 Pixels involved in the filter on / off decision are illustrated. For the first four rows, use 6 pixels in the two red boxes to determine the filter on / off for the four rows. For the second four rows, use 6 pixels in the two red boxes to determine the filter on / off for the second four rows.

[0050] If dp0 + dq0 + dp3 + dq3 < β, turn on the filtering for the first four rows and apply the strong / weak filter selection process. Derive each variable as follows.

[0051] dp0 = |p 2,0 –2*p 1,0 +p 0,0 |, dp3 = |p 2,3 –2*p 1,3 +p 0,3 |, dp4 = |p 2,4 –2*p 1,4 +p 0,4 |, dp7 = |p 2,7 –2*p 1,7 +p 0,7 |

[0052] dq0 = |q 2,0 –2*q 1,0 +q 0,0 |, dq3 = |q 2,3 –2*q 1,3 +q 0,3 |, dq4 = |q 2,4 –2*q 1,4 +q 0,4 |, dq7 = |q 2,7 –2*q 1,7 +q 0,7 |

[0053] If the conditions are not met, the first four lines are not filtered. Additionally, if the conditions are met, dE, dEp1, and dEp2 are derived for the weak filtering process. The variable dE is set to be equal to 1. If dp0 + dp3 < (β + (β >> 1)) >> 3, the variable dE1 is set to be equal to 1. If dp0 + dp3 < (β + (β >> 1)) >> 3, the variable dE1 is set to be equal to 1.

[0054] For the second four lines, a decision is made in the same way as above.

[0055] 2.1.5. Strong / Weak Filter Selection for Four Lines

[0056] After determining to filter the first four lines in the filter on / off decision, if the following two conditions are met, a strong filter is used to filter the first four lines. Otherwise, a weak filter is used for filtering. The pixels involved are the same as those for the filter on / off decision, as Figure 4 depicted.

[0057] 1) 2 * (dp0 + dq0) < (β >> 2), |p30 – p00| + |q00 – q30| < (β >> 3) and |p00 – q00| < (5 * t C + 1) >> 1

[0058] 2) 2 * (dp3 + dq3) < (β >> 2), |p33 – p03| + |q03 – q33| < (β >> 3) and |p03 – q03| < (5 * t C + 1) >> 1

[0059] In the same way, if the following two conditions are met, a strong filter is used to filter the second four lines. Otherwise, a weak filter is used for filtering.

[0060] 1) 2 * (dp4 + dq4) < (β >> 2), |p34 – p04| + |q04 – q34| < (β >> 3) and |p04 – q04| < (5 * t C + 1) >> 1

[0061] 2) 2 * (dp7 + dq7) < (β >> 2), |p37 – p07| + |q07 – q37| < (β >> 3) and |p07 – q07| < (5 * t C + 1) >> 1

[0062] 2.1.5.1 Strong Filtering

[0063] For strong filtering, the filtered pixel values are obtained through the following equations. It should be noted that four pixels are used as inputs for each P and Q block respectively to modify three pixels.

[0064] p0' = (p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3

[0065] q0' = (p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3

[0066] p1' = (p2 + p1 + p0 + q0 + 2) >> 2

[0067] q1' = (p0 + q0 + q1 + q2 + 2) >> 2

[0068] p2' = (2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3

[0069] q2' = (p0 + q0 + q1 + 3 * q2 + 2 * q3 + 4) >> 3

[0070] 2.1.5.2 Weak Filtering

[0071] In some embodiments, Δ can be defined as follows.

[0072] Δ = (9 * (q0 – p0) – 3 * (q1 – p1) + 8) >> 4

[0073] When abs(Δ) is less than tc * 10,

[0074] Δ = Clip3(-t C , t C , Δ)

[0075] p0' = Clip1 Y (p0 + Δ)

[0076] q0' = Clip1 Y (q0 - Δ)

[0077] If dEpl equals 1,

[0078] Δp = Clip3(-(t C >> 1), t C >> 1, (((p2 + p0 + 1) >> 1) - p1 + Δ) >> 1)

[0079] p1' = Clipl Y (p1 + Δp)

[0080] If dEpl equals 1,

[0081] Δq = Clip3(-(t C >> 1), t C >> 1, (((q2 + q0 + 1) >> 1) - q1 - Δ) >> 1)

[0082] q1’ = Clip1 Y (q1 + Δq)

[0083] It should be noted that the maximum two pixels are modified by using three pixels respectively as the input for each P and Q block.

[0084] 2.1.5.3 Chrominance Filtering

[0085] The Bs of chrominance filtering is inherited from luminance. If Bs > 1 or if there are coded chrominance coefficients, chrominance filtering is performed. There are no other filtering decisions. And only one filter is applied to chrominance. The filter selection process is not used for chrominance. The filtered sample values p0’ and q0’ are derived as follows.

[0086] Δ = Clip3(-t C , t C , ((((q0 - p0) << 2) + p1 - q1 + 4) >> 3))

[0087] p0’ = Clip1 C (p0 + Δ)

[0088] q0’ = Clip1 C (q0 - Δ)

[0089] 2.2 Deblocking Scheme in VTM - 4.0

[0090] In the current VTM, namely VTM - 4.0, the deblocking scheme is used.

[0091] 2.2.1 Stronger Deblocking Filter for Luminance

[0092] When the samples on either side of the boundary belong to a large block, this proposal uses a bilinear filter. Samples belonging to a large block are defined as having a width >= 32 for vertical edges and a height >= 32 for horizontal edges.

[0093] The bilinear filter is listed as follows.

[0094] The block boundary samples p for i = 0 to Sp - 1 are replaced by linear interpolation as follows i and the block boundary samples q for j = 0 to Sp - 1 j (p i and q j (following the definitions in the above HEVC deblocking):

[0095] -p i ′ = (f i * Middle s，t + (64 - f i ) * Ps +(32) >> 6), clip to p i ±tcPD i

[0096] -q j ′ = (g j *Middle s，t +(64 - g j ) * Q s +(32) >> 6), clip to q j ±tcPD j

[0097] where tcPD i and tcPD j terms are position - related clipping as described in Section 2.2.5 and g is given as follows j , f i , Middle s，t , P s and Q s :

[0098]

[0099]

[0100] 2.2.2 Inter - frame Prediction Modes in WC

[0101] The de - blocking decision process is described in this sub - section.

[0102] The wider and stronger luma filter is a filter that is used only if Conditions 1, 2, and 3 are all TRUE.

[0103] Condition 1 is the "large - block condition". This condition detects whether the samples on the P - side and Q - side belong to large blocks, which are represented by the variables bSidePisLargeBlk and bSideQisLargeBlk respectively. bSidePisLargeBlk and bSideQisLargeBlk are defined as follows.

[0104] bSidePisLargeBlk = ((the edge class is vertical and p0 belongs to a CU with width >= 32) || (the edge class is horizontal and p0 belongs to a CU with height >= 32))? true : false

[0105] bSideQisLargeBlk = ((the edge class is vertical and q0 belongs to a CU with width >= 32) || (the edge class is horizontal and q0 belongs to a CU with height >= 32))? true : false

[0106] Based on bSidePisLargeBlk and bSideQisLargeBlk, Condition 1 is defined as follows. Condition 1 = (bSidePisLargeBlk || bSidePisLargeBlk)? true : false

[0107] Next, if Condition 1 is true, Condition 2 will be further checked. First, the following variables are derived:

[0108] As in HEVC, first derive dp0, dp3, dq0, dq3

[0109] If the p side is greater than or equal to 32

[0110] dp0 = (dp0 + Abs(p 5，0 - 2 * p 4，0 + p 3，0 )) + 1) >> 1

[0111] dp3 = (dp3 + Abs(p 5，3 - 2 * p 4，3 + p 3，3 )) + 1) >> 1

[0112] If the q side is greater than or equal to 32

[0113] dq0 = (dq0 + Abs(q 5，0 - 2 * q 4，0 + q 3，0 )) + 1) >> 1

[0114] dq3 = (dq3 + Abs(q 5，3 - 2 * q 4，3 + q 3，3 )) + 1) >> 1

[0115] Then, as in HEVC, derive dpq0, dpq3, dp, dq, d.

[0116] Then, Condition 2 is defined as follows.

[0117] Condition 2 = (d < β)? true : false

[0118] As shown in Section 2.1.4, where d = dp0 + dq0 + dp3 + dq3.

[0119] If Conditions 1 and 2 are valid, check if any block uses sub - blocks:

[0120]

[0121] Finally, if both Conditions 1 and 2 are valid, the proposed de - blocking method will check Condition 3 (large - block strong filter condition), which is defined as follows.

[0122] In the condition 3 StrongFilterCondition, the following variables are derived:

[0123]

[0124] 2.2.3. Strong Deblocking Filter for Chrominance

[0125] The following strong deblocking filter for chrominance is defined:

[0126] p2′ = (3 * p3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3

[0127] p1′ = (2 * p3 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3

[0128] p0′ = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3

[0129] The proposed chrominance filter performs deblocking on a 4x4 chrominance sample grid.

[0130] 2.2.4. Chrominance Deblocking Control

[0131] The chrominance strong filter is used on both sides of the block boundary. Here, when both sides of the chrominance edge are greater than or equal to 8 (chrominance position), and the following three conditions are met for the decision, the chrominance filter is selected: The first is the decision for the boundary strength and large blocks. When the block width or height orthogonal to the block edge is equal to or greater than 8 in the chrominance sample domain, the proposed filter can be applied. The second and third decisions are basically the same as the HEVC luma deblocking decisions, which are the on / off decision and the strong filter decision respectively.

[0132] In the first decision, for chrominance filtering, the boundary strength (bS) is modified as shown in Table 1. Check the conditions in Table 2 sequentially. If the condition is met, skip the remaining conditions with lower priority.

[0133] Table 2. Modified Boundary Strength in JVET-M0471

[0134]

[0135] When bS is equal to 2, or when bS is equal to 1 when a large block boundary is detected, chrominance deblocking is performed.

[0136] The second and third conditions are basically the same as the HEVC luma strong filter decision, as follows.

[0137] In the second condition:

[0138] Then, derive d as in HEVC luma deblocking.

[0139] The second condition is true when d is less than β.

[0140] In the third condition StrongFilterCondition, it is derived as follows:

[0141] Derive dpq as in HEVC.

[0142] sp3 = Abs(p3 - p0), as derived in HEVC

[0143] sq3 = Abs(q0 - q3), as derived in HEVC

[0144] As derived in HEVC, StrongFilterCondition = (dpq is less than (β >> 2), sp3 + sq3 is less than (β >> 3), and Abs(p0 - q0) is less than (5 * t C + 1) >> 1)

[0145] 2.2.5. Position - dependent Clipping

[0146] The proposal also introduces position - dependent clipping tcPD, which is applied to the output samples of the luma filtering process for strong and long filters that involve modifying 7, 5, and 3 samples at the boundaries. Assuming the quantization error distribution, it is proposed to increase the clipping values of the samples expected to have higher quantization noise, so that the reconstructed sample values are expected to have a higher deviation compared to the true sample values.

[0147] Depending on the result of the decision - making process described in Section 2.2, for each P or Q boundary filtered using the proposed asymmetric filter, select the position - dependent threshold table from the Tc7 and Tc3 tables provided to the decoder as side information:

[0148] Tc7 = {6, 5, 4, 3, 2, 1, 1};

[0149] Tc3 = {6, 4, 2};

[0150] tcPD = (SP == 3)? Tc3 : Tc7;

[0151] tcQD = (SQ == 3)? Tc3 : Tc7;

[0152] For P or Q boundaries filtered using short symmetric filters, apply lower - magnitude position - dependent thresholds:

[0153] Tc3 = {3, 2, 1};

[0154] After defining the thresholds, clip the filtered p' according to the tcP and tcQ clipping values i and q' i Sample values:

[0155] p” i = clip3(p' i + tcP i , p' i – tcP i , p' i );

[0156] q” j = clip3(q' j + tcQ j , q' j – tcQ j , q' j );

[0157] where p' i and q' i are the filtered sample values, p” i and q” j are the output sample values after clipping, tcP i and tcQ j are the clipping thresholds derived from the VVC tc parameters and tcPD and tcQD. The term clip3 is the clipping function as specified in VVC.

[0158] 2.2.6. Sub-block Deblocking Adjustment

[0159] To enable parallel-friendly deblocking that uses both long filters and sub-block deblocking, limit the long filter to modify at most 5 samples on one side that uses sub-block deblocking (AFFINE or ATMVP), as shown for the luminance control of the long filter. Additionally, adjust the sub-block deblocking such that the sub-block boundaries on the 8×8 grid close to the CU or implicit TU boundary are limited to modify at most 2 samples on each side.

[0160] The following applies to sub-block boundaries that are not aligned with the CU boundary.

[0161]

[0162] where the side equal to 0 corresponds to the CU boundary, the side equal to 2 or equal to orthogonalLength - 2 corresponds to the sub-block boundary 8 samples from the CU boundary, and so on. Where if the implicit split of the TU is used, the implicit TU is true.

[0163] 2.2.7. Limitations on the 4CTU / 2CTU Line Buffers for Luminance / Chroma

[0164] When the horizontal boundary is aligned with the CTU boundary, the filtering of the horizontal boundary is limited to Sp = 3 for luminance and Sp = 1 and Sq = 1 for chrominance.

[0165] 2.3 Deblocking Specification in VVC Draft 5

[0166] 8.8.3. Deblocking Filter Process

[0167] 8.8.3.1. Overview

[0168] The input to this process is the reconstructed picture before deblocking, i.e., the array recPictureL, and when ChromaArrayType is not equal to 0, the arrays recPictureCb and recPictureCr.

[0169] The output of this process is the modified reconstructed picture after deblocking, i.e., the array recPictureL, and when ChromaArrayType is not equal to 0, the arrays recPictureCb and recPictureCr. First, filter the vertical edges in the picture. Then, use the samples modified by the vertical edge filtering process as input to filter the horizontal edges in the picture. The vertical and horizontal edges in the CTB of each CTU are processed separately based on the coding unit. Starting from the edge on the left - hand side of the coding block, filter the vertical edges of the coding block in the coding unit by advancing through the edges in their geometric order towards the right - hand side of the coding block. Starting from the edge at the top of the coding block, filter the horizontal edges of the coding block in the coding unit by advancing through the edges in their geometric order towards the bottom of the coding block.

[0170] Note – Although the filtering process is specified on the basis of the picture in this specification, if the decoder appropriately considers the processing dependency order to produce the same output values, the filtering process can be implemented on the basis of the coding unit to obtain equivalent results. The deblocking filter process is applied to all coding sub - block edges and transform block edges in the picture, except for the following types of edges:

[0171] – Edges at the picture boundary,

[0172] – Edges that coincide with the virtual boundary of the picture when PPS_loop_filter_cross_virtual_boundaries_disabled_flag is equal to 1,

[0173] – Edges that coincide with the brick boundary when loop_filter_across_bricks_enabled_flag is equal to 0,

[0174] – When loop_filter_across_slices_enabled_flag is equal to 0, the edges that coincide with the slice boundary,

[0175] – The edges that coincide with the upper or left boundary of a slice where slice_deblocking_filter_disabled_flag is equal to 1,

[0176] – The edges within a slice where slice_deblocking_filter_disabled_flag is equal to 1,

[0177] – The edges that do not correspond to the boundaries of the 8×8 sample grid of the considered component,

[0178] – The edges in the luma component for which intra_bdpcm_flag is equal to 1 on both sides of the edge.

[0179] – The edges of the chroma sub-blocks that are not the edges of the associated transform unit.

[0180] The edge type (vertical or horizontal) is represented by the variable edgeType specified in Table 8-19.

[0181] Table 8-19 – Names associated with edge types

[0182] edgeType Name of edgeType 0 (Vertical edge) EDGE_VER 1 (Horizontal edge) EDGE_HOR

[0183] When slice_deblocking_filter_disabled_flag of the current slice is equal to 0, the following is applied:

[0184] – The derivation of the variable treeType is as follows:

[0185] – If slice_type is equal to I and qtbtt_dual_tree_intra_flag is equal to 1, then treeType is set to be equal to DUAL_TREE_LUMA.

[0186] – Otherwise, treeType is set to be equal to SINGLE_TREE.

[0187] – Taking as input the variable treeType, the reconstructed picture before deblocking (i.e., the array recPictureL), and the arrays recPictureCb and recPictureCr when ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE, and the variable edgeType set to be equal to EDGE_VER, and taking as output the modified reconstructed picture after deblocking (i.e., the array recPictureL), and the arrays recPictureCb and recPictureCr when ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE, filter the vertical edges by calling the deblocking filter process for one direction specified in item 8.8.3.2.

[0188] – Taking as input the variable treeType, the reconstructed picture before deblocking (i.e., the array recPictureL), and the arrays recPictureCb and recPictureCr when ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE, and the variable edgeType set to be equal to EDGE_HOR, and taking as output the modified reconstructed picture after deblocking (i.e., the array recPictureL), and the arrays recPictureCb and recPictureCr when ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE, filter the horizontal edges by calling the deblocking filter process for one direction specified in item 8.8.3.2.

[0189] – When slice_type is equal to 1 and qtbtt_dual_tree_intra_flag is equal to 1, apply the following cases:

[0190] – The variable treeType is set to be equal to DUAL_TREE_CHROMA

[0191] – Taking as input the variable treeType, the reconstructed pictures before deblocking (i.e., the arrays recPictureCb and recPictureCr), and the variable edgeType set to be equal to EDGE_VER, and taking as output the modified reconstructed pictures after deblocking (i.e., the arrays recPictureCb and recPictureCr), filter the vertical edges by calling the deblocking filter process for one direction specified in item 8.8.3.2.

[0192] – Taking as input the variable treeType, the reconstructed picture before deblocking (i.e., the arrays recPictureCb and recPictureCr), and the variable edgeType set to be equal to EDGE_HOR, and taking as output the modified reconstructed picture after deblocking (i.e., the arrays recPictureCb and recPictureCr), filter the horizontal edges by calling the deblocking filter process for one direction specified in item 8.8.3.2.

[0193] 8.8.3.2. Deblocking Filter Process for One Direction

[0194] The inputs to this process are:

[0195] – The variable treeType, which specifies whether to use single tree (SINGLE_TREE) or dual tree partitioning of the CTU, and when using dual tree, whether the currently processed component is luminance (DUAL_TREE_LUMA) or chrominance (DUAL_TREE_COMMITY).

[0196] – When treeType is equal to SIGNAL_TREE or DUAL_TREE_LUMA, the reconstructed picture before deblocking (i.e., the array recPictureL).

[0197] – When ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE or DUAL_TREE_CHROMA, recPictureCb and recPictureCr.

[0198] – The variable edgeType, which specifies whether to filter vertical edges (EDGE_VER) or horizontal edges (EDGE_HOR).

[0199] The output of this process is the modified reconstructed picture after deblocking, i.e.:

[0200] – When treeType is equal to SINGLE_TREE or DUAL_TREE_LUMA, the array recPictureL.

[0201] – When ChromaArrayType is not equal to 0 and treeType is equal to SINGLE_TREE or DUAL_TREE_CHROMA, the arrays recPictureCb and recPictureCr.

[0202] The derivation of the variables firstCompIdx and lastCompIdx is as follows:

[0203] first compidx = (treeType == DUAL_TREE_CHROME)? 1 : 0

[0204] (8 - 1004)

[0205] lastCompIdx = (treeType == DUAL_TREE_LUMA || chromararytype == 0)? 0 : 2(8 - 1005)

[0206] For each coding unit indicated by a color component index cIdx ranging from firstCompIdx to lastCompIdx (inclusive) and for each coding block of each color component of each coding unit, where the coding block width nCbW, coding block height nCbH, and the position (xCb, yCb) of the top - left sample of the coding block, when edgeType is equal to EDGE_VER and xCb % 8 is equal to 0, or when edgeType is equal to EDGE_HOR and yCb % 8 is equal to 0, the edges are filtered by the following ordered steps:

[0207] 1. The variable filterEdgeFlag is derived as follows:

[0208] – If edgeType is equal to EDGE_VER and one or more of the following conditions are true, then filterEdgeFlag is set to be equal to 0:

[0209] – The left boundary of the current coding block is the left boundary of the picture.

[0210] – The left boundary of the current coding block is the left boundary of a tile and loop_filter_across_bricks_enabled_flag is equal to 0.

[0211] – The left boundary of the current coding block is the left boundary of a slice and loop_filter_across_slices_enabled_flag is equal to 0.

[0212] – The left boundary of the current coding block is one of the vertical virtual boundaries of the picture and PPS_loop_filter_cross_virtual_boundaries_disabled_flag is equal to 1.

[0213] – Otherwise if edgeType is equal to EDGE_HOR and one or more of the following conditions are true, then the variable filterEdgeFlag is set to be equal to 0:

[0214] – The top boundary of the current luma coding block is the top boundary of the picture.

[0215] – The top boundary of the current coding block is the top boundary of the tile, and loop_filter_across_bricks_enabled_flag is equal to 0.

[0216] – The top boundary of the current coding block is the top boundary of the slice, and loop_filter_across_slices_enabled_flag is equal to 0.

[0217] – The top boundary of the current coding block is one of the horizontal virtual boundaries of the picture, and PPS_loop_filter_cross_virtual_boundaries_disabled_flag is equal to 1.

[0218] – Otherwise, filterEdgeFlag is set to be equal to 1.

[0219] 2. All elements of the two-dimensional (nCbW)x(nCbH) arrays edgeFlags, maxFilterLengthQs, and maxFilterlengthPs are initialized to be equal to zero.

[0220] 3. Call the process for deriving the transformed block boundaries specified in Clause 8.8.3.3 with the position (xCb, yCb), coding block width nCbW, coding block height nCbH, variable cIdx, variable filterEdgeFlag, array edgeFlags, maximum filter length arrays maxFilterLengthPs and maxFilterLengthQs, and variable edgeType as inputs, and with the modified edgeFlags, modified maximum filter length arrays maxFilterLengthPs and maxFilterLengthQs as outputs.

[0221] 4. When cIdx is equal to 0, call the process for deriving the coding sub-block boundaries specified in Clause 8.8.3.4 with the position (xCb, yCb), coding block width nCbW, coding block height nCbH, array edgeFlags, maximum filter length arrays maxFilterLengthPs and maxFilterLengthQs, and variable edgeType as inputs, and with the modified array edgeFlags, modified maximum filter length arrays maxFilterLengthPs and maxFilterLengthQs as outputs.

[0222] 5. The derivation of the picture sample array recPicture is as follows:

[0223] – If cIdx is equal to 0, then recPicture is set to be equal to the reconstructed luma picture sample array recPictureL before deblocking.

[0224] – Otherwise, if cIdx is equal to 1, then recPicture is set to be equal to the reconstructed chroma picture sample array recPictureCb before deblocking.

[0225] – Otherwise (cIdx is equal to 2), recPicture is set to be equal to the reconstructed chroma picture sample array recPictureCr before deblocking.

[0226] 6. Call the derivation process of the boundary filtering strength specified in Clause 8.8.3.5 with the picture sample array recPicture, the luma positions (xCb, yCb), the coded block width nCbW, the coded block height nCbH, the variable edgeType, the variable cIdx, and the array edgeFlags as inputs, and with the (nCbW) x (nCbH) array bS as the output.

[0227] 7. Call the edge filtering process for one direction specified in Clause 8.8.3.6 for the coded block with the variable edgeType, the variable cIdx, the reconstructed picture recPicture before deblocking, the positions (xCb, yCb), the coded block width nCbW, the coded block height nCbH, and the arrays bS, maxFilterLengthPs, and maxFilterLengthQs as inputs, and with the modified reconstructed picture recPicture as the output.

[0228] 8.8.3.3. Derivation process of the transform block boundary

[0229] The inputs to this process are:

[0230] – Specify the position (xCb, yCb) of the top-left sample of the current coded block relative to the top-left sample of the current picture.

[0231] – The variable nCbW, which specifies the current coded block width.

[0232] – The variable nCbH, which specifies the current coded block height.

[0233] – The variable cIdx, which specifies the color component of the current coded block.

[0234] – The variable filterEdgeFlag.

[0235] – Two-dimensional (nCbW) x (nCbH) array edgeFlags,

[0236] – Two-dimensional (nCbW) x (nCbH) arrays maxFilterLengthQs and maxFilterLengthPs,

[0237] – Variable edgeType, specifying whether to filter vertical (EDGE_VER) or horizontal (EDGE_HOR) edges.

[0238] The output of the process is:

[0239] – Modified two-dimensional (nCbW) x (nCbH) array edgeFlags,

[0240] – Modified two-dimensional (nCbW) x (nCbH) arrays maxFilterLengthQs, maxFilterLengthPs.

[0241] Depending on edgeType, the derivation of arrays edgeFlags, maxFilterLengthPs, and maxFilterLengthQs is as follows:

[0242] – If edgeType is equal to EDGE_VER, then the following applies:

[0243] – Variable numEdges is set to be equal to Max(1, nCbW / 8).

[0244] – For xEdge = 0..numEdges - 1 and y = 0..nCbH - 1, then the following applies:

[0245] – The horizontal position x within the current coding block is set to be equal to xEdge * 8.

[0246] – The value of edgeFlags[x][y] is derived as follows:

[0247] If pps_loop_filter_across_virtual_boundaries_disabled_flag is equal to 1 and for any n = 0..pps_num_ver_virtual_boundaries - 1, (xCb + x) is equal to PpsVirtualBoundariesPosX[n], then edgeFlags[x][y] is set to be equal to 0.

[0248] Otherwise, if x is equal to 0, then edgeFlags[x][y] is set to be equal to filterEdgeFlag.

[0249] Otherwise, if the position (xCb + x, yCb + y) is located at the edge of the transform block, edgeFlags[x][y] is set to be equal to 1.

[0250] – When edgeFlags[x][y] is equal to 1, the following applies:

[0251] If cIdx is equal to 0, the following applies:

[0252] The value of maxFilterLengthQs[x][y] is derived as follows:

[0253] If the width of the luma samples of the transform block at the luma position (xCb + x, yCb + y) is equal to or greater than 32, maxFilterLengthQs[x][y] is set to be equal to 7.

[0254] Otherwise, maxFilterLengthQs[x][y] is set to be equal to 3.

[0255] The value of maxFilterLengthPS[x][y] is derived as follows:

[0256] If the width of the luma samples of the transform block at the luma position (xcb + x - 1, yCb + y) is equal to or greater than 32, maxFilterLengthPs[x][y] is set to be equal to 7.

[0257] Otherwise, maxFilterLengthPs[x][y] is set to be equal to 3.

[0258] Otherwise (cIdx is not equal to 0), the values of maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are derived as follows:

[0259] If the chroma sample width of the transform block at the chroma position (xCb + x, yCb + y) and the width at the chroma position (xcb + x - 1, yCb + y) are both equal to or greater than 8, maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are set to be equal to 3.

[0260] Otherwise, maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are set to be equal to 1.

[0261] – Otherwise (edgeType is equal to EDGE_HOR), the following applies:

[0262] – The variable numEdges is set to be equal to Max(1, nCbH / 8).

[0263] – For yEdge = 0..numages - 1 and x = 0..nCbW - 1, the following applies:

[0264] – The vertical position y within the current coding block is set to be equal to yEdge * 8.

[0265] – The value of edgeFlags[x][y] is derived as follows:

[0266] If pps_loop_filter_across_virtual_boundaries_disabled_flag is equal to 1 and for any n = 0..PPS_num_hor_virtual_boundaries - 1, (yCb + y) is equal to PpsVirtualBoundariesPosY[n], then edgeFlags[x][y] is set to be equal to 0.

[0267] Otherwise, if y is equal to 0, then edgeFlags[x][y] is set to be equal to filterEdgeFlag.

[0268] Otherwise, if the position (xCb + x, yCb + y) is at the edge of the transform block, then edgeFlags[x][y] is set to be equal to 1.

[0269] – When edgeFlags[x][y] is equal to 1, the following applies:

[0270] If cIdx is equal to 0, the following applies:

[0271] The value of maxFilterLengthQs[x][y] is derived as follows:

[0272] If the height of the luma samples of the transform block at the luma position (xCb + x, yCb + y) is equal to or greater than 32, then maxFilterLengthQs[x][y] is set to be equal to 7.

[0273] Otherwise, maxFilterLengthQs[x][y] is set to be equal to 3.

[0274] The value of maxFilterLengthPs[x][y] is derived as follows:

[0275] If the height of the luma samples of the transform block at the luma position (xCb + x, ycb + y - 1) is equal to or greater than 32, then maxFilterLengthPs[x][y] is set to be equal to 7.

[0276] Otherwise, maxFilterLengthPs[x][y] is set to be equal to 3.

[0277] Otherwise (cIdx not equal to 0), the values of maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are derived as follows:

[0278] If all of the following conditions are true, then maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are set to be equal to 3:

[0279] The height of the chroma samples of the transform block at the chroma position (xCb + x, yCb + y) and the height at the chroma position (xCb + x, ycb + y - 1) are both equal to or greater than 8.

[0280] (YCb + y) % CtbHeightC is greater than 0, i.e., the horizontal edge does not overlap with the upper chroma CTB boundary.

[0281] Otherwise, maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are set to be equal to 1.

[0282] 8.8.3.4. Derivation Process of Coding / Decoding Sub - block Boundaries

[0283] The inputs to this process are:

[0284] – Specify the position (xCb, yCb) of the top - left sample of the current coding / decoding block relative to the top - left sample of the current picture,

[0285] – Variable nCbW, specifying the width of the current coding / decoding block,

[0286] – Variable nCbH, specifying the height of the current coding / decoding block,

[0287] – Variable cIdx, specifying the color component of the current coding / decoding block,

[0288] – Variable filterEdgeFlag,

[0289] – Two - dimensional (nCbW) x (nCbH) array edgeFlags,

[0290] – Two-dimensional (nCbW) x (nCbH) arrays maxFilterLengthQs and maxFilterLengthPs,

[0291] – Variable edgeType, specifying whether to filter vertical edges (EDGE_VER) or horizontal edges (EDGE_HOR).

[0292] The output of this process is:

[0293] – Modified two-dimensional (nCbW) x (nCbH) array edgeFlags,

[0294] – Modified two-dimensional (nCbW) x (nCbH) arrays maxFilterLengthQs, maxFilterLengthPs.

[0295] The derivation of the number of coding / decoding sub-blocks in the horizontal direction numSbX and the number of coding / decoding sub-blocks in the vertical direction numSbY is as follows:

[0296] – If inter_affine_flag[xCb][yCb] is equal to 1 or merge_subblock_flag[xCb][yCb] is equal to 1, then numSbX and numSbY are respectively set to be equal to NumSbX[xCb][yCb] and NumSbY[xCb][yCb].

[0297] – Otherwise, both numSbX and numSbY are set to be equal to 1.

[0298] Depending on the value of edgeType, the following applies:

[0299] – If edgeType is equal to EDGE_VER, the following applies:

[0300] – Variable sbW is set to be equal to Max(8, nCbW / numSbX).

[0301] – Array edgeTbFlags is set to be equal to edgeFlags.

[0302] – For xEdge = 0.. minimum((NCBw / 8) - 1, NumSbX - 1), y = 0.. nCbH - 1:

[0303] – The horizontal position x within the current coding / decoding block is set to be equal to xEdge * sbW.

[0304] – The value of edgeFlags[x][y] is derived as follows:

[0305] – If pps_loop_filter_across_virtual_boundaries_disabled_flag equals 1, and for any n = 0..pps_num_ver_virtual_boundaries-1, x equals PpsVirtualBoundariesPosX[n], then the following applies:

[0306] edge flags[x][y] = 0(8-1006)

[0307] – Otherwise, the following applies:

[0308] edge flags[x][y] = 1(8-1007)

[0309] – When edgeFlags[x][y] equals 1, the values of maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are modified as follows:

[0310] – If x equals 0, then the following applies:

[0311] – When numSbX is greater than 1, the following applies:

[0312] maxFilterLengthQs[x][y] = Min(5,maxFilterLengthQs[x][y])(8-1008)

[0313] – When inter_affine_flag[xCb-1][yCb] equals 1 or merge_subblock_flag[xCb-1][yCb] equals 1, the following applies:

[0314] maxFilterLengthPs[x][y] = Min(5,maxFilterLengthPs[x][y])(8-1009)

[0315] – Otherwise, if edgeTbFlags[x][y] equals 1, then the following applies:

[0316] maxFilterLengthPs[x][y] = Min(5,maxFilterLengthPs[x][y])(8-1010)

[0317] maxFilterLengthQs[x][y] = Min(5,maxFilterLengthQs[x][y])(8-1011)

[0318] – Otherwise, if one or more of the following conditions are true:

[0319] – Xedge equals 1,

[0320] – Xedge equals (NCBw / 8)-1,

[0321] – EdgeTBflags[x-SbW][y] equals 1,

[0322] – EdgeTBflags[x+SbW][y] equals 1,

[0323] then the following applies:

[0324] maxFilterLengthPs[x][y] = 2(8 - 1012)

[0325] maxFilterLengthQs[x][y] = 2(8 - 1013)

[0326] – Otherwise, the following applies:

[0327] maxFilterLengthPs[x][y] = 3(8 - 1014)

[0328] maxFilterLengthQs[x][y] = 3(8 - 1015)

[0329] – Otherwise, if edgeType equals EDGE_HOR, then the following applies:

[0330] – The variable sbH is set to equal Max(8, nCbH / numSbY).

[0331] – The array edgeTbFlags is set to equal edgeFlags.

[0332] – For yEdge = 0..min((NCbh / 8)-1, NumSby-1), x = 0..nCbW-1:

[0333] – The vertical position y within the current coding block is set to equal yEdge * sbH.

[0334] – The value of edgeFlags[x][y] is derived as follows:

[0335] – If pps_loop_filter_across_virtual_boundaries_disabled_flag equals 1, and for any n = 0..pps_num_hor_virtual_boundaries-1, y equals PpsVirtualBoundariesPosY[n], then the following applies:

[0336] edge flags[x][y] = 0(8-1016)

[0337] – Otherwise, the following applies:

[0338] edge flags[x][y] = 1(8-1017)

[0339] – When edgeFlags[x][y] equals 1, the values of maxFilterLengthPs[x][y] and maxFilterLengthQs[x][y] are modified as follows:

[0340] – If y equals 0, and edgeFlags[x][y] equals 1, then the following applies:

[0341] – When numSbY is greater than 1, the following applies: maxFilterLengthQs[x][y] = Min(5,maxFilterLengthQs[x][y])(8-1018)

[0342] – When inter_affine_flag[xCb][yCb-1] equals 1 or merge_subblock_flag[xCb][yCb-1] equals 1, the following applies: maxFilterLengthPs[x][y] = Min(5,maxFilterLengthPs[x][y])(8-1019)

[0343] – Otherwise, if edgeTbFlags[x][y] equals 1, then the following applies:

[0344] maxFilterLengthPs[x][y] = Min(5,maxFilterLengthPs[x][y])(8-1020)

[0345] maxFilterLengthQs[x][y] = Min(5,maxFilterLengthQs[x][y])(8-1021)

[0346] – Otherwise, if one or more of the following conditions are true:

[0347] – The –yEdge is equal to 1,

[0348] – The –yEdge is equal to (NCbh / 8) - 1,

[0349] – The edgeTbFlags[x][y - sbH] is equal to 1,

[0350] – The edgeTbFlags[x][y + sbH] is equal to 1,

[0351] Then the following applies:

[0352] maxFilterLengthPs[x][y] = 2(8 - 1022)

[0353] maxFilterLengthQs[x][y] = 2(8 - 1023)

[0354] – Otherwise, the following applies:

[0355] maxFilterLengthPs[x][y] = 3(8 - 1024)

[0356] maxFilterLengthQs[x][y] = 3(8 - 1025)

[0357] 8.8.3.5. Derivation Process of Boundary Filtering Strength

[0358] The inputs to this process are:

[0359] – The picture sample array recPicture,

[0360] – Specify the position (xCb, yCb) of the top - left sample of the current coding / decoding block relative to the top - left sample of the current picture,

[0361] – The variable nCbW, which specifies the width of the current coding / decoding block,

[0362] – The variable nCbH, which specifies the height of the current coding / decoding block

[0363] – The variable edgeType, which specifies whether to filter a vertical edge (EDGE_VER) or a horizontal edge (EDGE_HOR),

[0364] – The variable cIdx, which specifies the color component of the current coding / decoding block,

[0365] – The two - dimensional (nCbW) x (nCbH) array edgeFlags.

[0366] The output of this process is a two-dimensional (nCbW) x (nCbH) array bS that specifies the boundary filtering strength.

[0367] The variables xDi, yDj, xN, and yN are derived as follows:

[0368] – If edgeType is equal to EDGE_VER,

[0369] xDi = (i << 3) - (8 - 1026)

[0370] yDj = cIdx == 0? (j << 2) : (j << 1) - (8 - 1027)

[0371] xN is set to be equal to Max(0, (nCbW / 8) - 1) - (8 - 1028)

[0372] yN = cIdx == 0? (NCbh / 4) - 1 : (NCbh / 2) - 1 - (8 - 1029)

[0373] – Otherwise (edgeType is equal to EDGE_HOR),

[0374] xDi = cIdx == 0? (i << 2) : (i << 1) - (8 - 1030)

[0375] yDj = (j << 3) - (8 - 1031)

[0376] xN = cIdx == 0? (NCBw / 4) - 1 : (NCBw / 2) - 1 - (8 - 1032)

[0377] yN = Max(0, (NCbh / 8) - 1) - (8 - 1033)

[0378] For xDi where i = 0..xN and yDj where j = 0..yN, the following applies:

[0379] – If edgeFlags[xDi][yDj] is equal to 0, the variable bS[xDi][yDj] is set to be equal to 0.

[0380] – Otherwise, the following applies:

[0381] – The sample values p0 and q0 are derived as follows:

[0382] – If edgeType is equal to EDGE_VER, p0 is set to be equal to recPicture[xCb + xDi - 1][yCb + yDj], and q0 is set to be equal to recPicture[xCb + xDi][yCb + yDj].

[0383] – Otherwise (when edgeType equals EDGE_HOR), p0 is set to be equal to recPicture[xCb + xDi][yCb + yDj - 1], and q0 is set to be equal to recPicture[xCb + xDi][yCb + yDj].

[0384] – The variable bS[xDi][yDj] is derived as follows:

[0385] – If cIdx equals 0, and both sample points p0 and q0 are in the coding / decoding block where intra_bdpcm_flag equals 1, then bS[xDi][yDj] is set to be equal to 0.

[0386] – Otherwise, if either sample point p0 or q0 is in the coding / decoding block of the coding / decoding unit coded / decoded using an intra prediction mode, then bS[xDi][yDj] is set to be equal to 2.

[0387] – Otherwise, if the block edge is also a transform block edge, and either sample point p0 or q0 is in the coding / decoding block where ciip_flag equals 1, then bS[xDi][yDj] is set to be equal to 2.

[0388] – Otherwise, if the block edge is also a transform block edge, and either sample point p0 or q0 is in a transform block containing one or more non - zero transform coefficient levels, then bS[xDi][yDj] is set to be equal to 1.

[0389] – Otherwise, if the prediction mode of the coding / decoding sub - block containing sample point p0 is different from the prediction mode of the coding / decoding sub - block containing sample point q0, then bS[xDi][yDj] is set to be equal to 1.

[0390] – Otherwise, if cIdx equals 0, and one or more of the following conditions are true, then bS[xDi][yDj] is set to be equal to 1:

[0391] – Both the coding / decoding sub - block containing sample point p0 and the coding / decoding sub - block containing sample point q0 are coded / decoded in IBC prediction mode, and the absolute difference between the horizontal or vertical components of the motion vectors used in the predictions of the two coding / decoding sub - blocks is greater than or equal to 4 in units of quarter - luminance samples.

[0392] – For the prediction of the coding / decoding sub - block containing sample point p0, a different reference picture or a different number of motion vectors is used compared to the prediction of the coding / decoding sub - block containing sample point q0.

[0393] Note 1 – The determination of whether the reference pictures used for two coding / decoding sub-blocks are the same or different is based only on which pictures are referenced, regardless of whether the indices of reference picture list 0 or reference picture list 1 are used to form the prediction, and also regardless of whether the index positions within the reference picture list are different.

[0394] Note 2 – The number of motion vectors for the prediction of a coding / decoding sub-block having a top-left sample with coverage (xSb, ySb) is equal to PredFlagL0[xSb][ySb] + PredFlagL1[xSb][ySb].

[0395] – One motion vector is used to predict the coding / decoding sub-block containing sample p0, and one motion vector is used to predict the coding / decoding sub-block containing sample q0, and the absolute difference between the horizontal or vertical components of the motion vectors used is greater than or equal to 4 in units of quarter luminance samples.

[0396] – Two motion vectors and two different reference pictures are used to predict the coding / decoding sub-block containing sample p0, two motion vectors for the same two reference pictures are used to predict the coding / decoding sub-block containing sample q0, and the absolute difference between the horizontal or vertical components of the two motion vectors for the prediction of the two coding / decoding sub-blocks for the same reference picture is greater than or equal to 4 in units of quarter luminance samples.

[0397] – Two motion vectors for the same reference picture are used to predict the coding / decoding sub-block containing sample p0, two motion vectors for the same reference picture are used to predict the coding / decoding sub-block containing sample q0, and both of the following conditions are true:

[0398] – The absolute difference between the horizontal or vertical components of the list 0 motion vectors for the prediction of the two coding / decoding sub-blocks is greater than or equal to 4 in units of quarter luminance samples, or the absolute difference between the horizontal or vertical components of the list 1 motion vectors for the prediction of the two coding / decoding sub-blocks is greater than or equal to 4 in units of quarter luminance samples.

[0399] – The absolute difference between the horizontal or vertical component of the list 0 motion vector used in the prediction of the coding / decoding sub-block containing sample p0 and the list 1 motion vector used in the prediction of the coding / decoding sub-block containing sample q0 is greater than or equal to 4 in units of quarter luminance samples, or the absolute difference between the horizontal or vertical component of the list 1 motion vector used in the prediction of the coding / decoding sub-block containing sample p0 and the list 0 motion vector used in the prediction of the coding / decoding sub-block containing sample q0 is greater than or equal to 4 in units of quarter luminance samples.

[0400] – Otherwise, the variable bS[xDi][yDj] is set to be equal to 0.

[0401] 8.8.3.6. Edge Filtering Process for One Direction

[0402] The inputs to this process are:

[0403] – The variable edgeType, which specifies whether the current processing is for vertical edges (EDGE_VER) or horizontal edges (EDGE_HOR),

[0404] – The variable cIdx, which specifies the current color component,

[0405] – The reconstructed picture recPicture before deblocking,

[0406] – The position (xCb, yCb) of the top-left sample of the current coding / decoding block relative to the top-left sample of the current picture,

[0407] – The variable nCbW, which specifies the width of the current coding / decoding block,

[0408] – The variable nCbH, which specifies the height of the current coding / decoding block,

[0409] – The array bS, which specifies the boundary strength,

[0410] – The arrays maxFilterLengthPs and maxFilterLengthQs.

[0411] The output of this process is the modified reconstructed picture recPicture after deblocking.

[0412] For the edge filtering process, the following applies:

[0413] – The variables subW, subH, xN, yN, xDk, and yDm are derived as follows:

[0414] subW = cIdx == 0? 1 : SubWidthC (8 - 1034)

[0415] subH = cIdx == 0? 1 : SubHeightC (8 - 1035)

[0416] xN = edgeType == EDGE_VER? Max(0, (nCbW / 8) - 1) : (nCbW / 4 / subW) - 1 (8 - 1036)

[0417] yN = edgeType == EDGE_VER? (nCbH / 4 / subH) - 1 : Max(0, (nCbH / 8) - 1) (8 - 1037)

[0418] xDk = edgeType == EDGE_VER? (k << 3) : (k << (2 / subW)) (8 - 1038)

[0419] yDm = edgeType == EDGE_VER? (m << (2 / subH)) : (m << 3) (8 - 1039)

[0420] – For xDk where k = 0..xN and yDm where m = 0..yN, the following applies:

[0421] – When bS[xDk][yDm] is greater than 0, the following ordered steps apply:

[0422] – If cIdx is equal to 0, the filtering process for the edges in the luma coding block for the current coding unit consists of the following ordered steps:

[0423] 1. Call the decision process for luma block edges specified in Clause 8.8.3.6.1 with the luma picture sample array recPicture, the position (xCb, yCb) of the luma coding block, the luma position (xBl, yBl) of the block set equal to (xDk, yDm), the edge direction edgeType, the boundary filtering strength bS[xDk][yDm], the maximum filter length maxFilterLengthPs set equal to maxFilterLengthPs[xDk][yDm], and the maxFilterLengthQs set equal to maxFilterLengthQs[xDk][yDm] as input, and with the decisions dE, dEp, and dEq, the modified maximum filter lengths maxFilterLengthP and maxFilterLengthQ, and the variable tC as output.

[0424] 2. Call the filtering process for block edges specified in Clause 8.8.3.6.2 with the luma picture sample array recPicture, the position (xCb, yCb) of the luma coding block, the luma position (xBl, yBl) of the block set equal to (xDk, yDm), the edge direction edgeType, the decisions dE, dEp, and dEq, the maximum filter lengths maxFilterLengthP and maxFilterLengthQ, and the variable tC as input, and with the modified luma picture sample array recPicture as output.

[0425] – Otherwise (cIdx is not equal to 0), the filtering process for the edges in the chroma coding block for the current coding unit specified by cIdx consists of the following ordered steps:

[0426] 1. The derivation of the variable cQpPicOffset is as follows:

[0427] cQpPicOffset = cIdx == 1? pps_cb_qp_offset : pps_cr_qp_offset (8 - 1040)

[0428] 2. Call the decision process for the chrominance block edge specified in item 8.8.3.6.3, with the chrominance picture sample array recPicture, the positions of the chrominance coding / decoding block (xCb, yCb), the positions of the chrominance block (xBl, yBl) set to be equal to (xDk, yDm), the edge direction edgeType, the variable cQpPicOffset, the boundary filtering strength bS[xDk][yDm], and the variable maxFilterLengthCbCr set to be equal to maxFilterLengthPs[xDk][yDm] as the input, and with the modified variable maxFilterLengthCbCr and the variable tC as the output.

[0429] 3. When maxFilterLengthCbCr is greater than 0, call the filtering process for the chrominance block edge specified in item 8.8.3.6.4, with the chrominance picture sample array recPicture, the positions of the chrominance coding / decoding block (xCb, yCb), the chrominance positions of the block (xBl, yBl) set to be equal to (xDk, yDm), the edge direction edgeType, the variable maxFilterLengthCbCr, and the variable tC as the input, and with the modified chrominance picture sample array recPicture as the output.

[0430] 8.8.3.6.1 Decision Process for Luminance Block Edge

[0431] The inputs to this process are:

[0432] – The picture sample array recPicture,

[0433] – Specify the position (xCb, yCb) of the top - left sample of the current coding / decoding block relative to the top - left sample of the current picture.

[0434] – Specify the position (xBl, yBl) of the top - left sample of the current block relative to the top - left sample of the current coding / decoding block.

[0435] – The variable edgeType, which specifies whether to filter a vertical edge (EDGE_VER) or a horizontal edge (EDGE_HOR),

[0436] – The variable bS, which specifies the boundary filtering strength,

[0437] – The variable maxFilterLengthP, which specifies the maximum filter length,

[0438] – The variable maxFilterLengthQ, which specifies the maximum filter length,

[0439] The output of this process is:

[0440] – The variables dE, dEp, and dEq that contain decisions,

[0441] – The modified filter length variables MaxFilterLengthP and maxFilterLengthQ,

[0442] – The variable tC.

[0443] The sample values pi,k and qj,k where i = 0..maxFilterLengthP, j = 0..maxFilterLengthQ, and k = 0..3 are derived as follows:

[0444] – If edgeType is equal to EDGE_VER, then the following applies:

[0445] qj,k = recPictureL[xCb + xBl + j][yCb + yBl + k] (8 - 1041)

[0446] pi,k = recPictureL[xCb + xBl - i - 1][yCb + yBl + k](8 - 1042)

[0447] – Otherwise (edgeType is equal to EDGE_HOR), the following applies:

[0448] qj,k = recPicture[xCb + xBl + k][yCb + yBl + j] (8 - 1043)

[0449] pi,k = recPicture[xCb + xBl + k][yCb + yBl - i - 1] (8 - 1044)

[0450] The variable qpOffset is derived as follows:

[0451] – If sps_ladf_enabled_flag is equal to 1, then the following applies:

[0452] – The variable lumaLevel of the reconstructed luma level is derived as follows:

[0453] lumaLevel = ((p0,0 + p0,3 + q0,0 + q0,3) >> 2),(8 - 1045)

[0454] – The variable qpOffset is set to be equal to sps_ladf_lowest_interval_qp_offset and is modified as follows:

[0455]

[0456]

[0457] – Otherwise, qpOffset is set to be equal to 0.

[0458] The variables QpQ and QpP are set to be equal to the QpY values of the coding units of the coded blocks containing the samples q0,0 and p0,0 respectively.

[0459] The variable qP is derived as follows:

[0460] qP = ((QpQ + QpP + 1) >> 1) + qpofset(8 - 1047)

[0461] Based on the quantization parameter Q derived as follows, the value of the variable β’ is determined as specified in Table 8 20:

[0462] Q = Clip3(0, 63, qP + (slice_beta_offset_div2 << 1))(8 - 1048)

[0463] where slice_beta_offset_div2 is the value of the syntax element slice_beta_offset_div2 for the slice containing the sample q0,0.

[0464] The variable β is derived as follows:

[0465] β = β′ * (1 << (BitDepthY - 8))(8 - 1049)

[0466] Based on the quantization parameter Q derived as follows, the value of the variable tC’ is determined as specified in Table 8 20:

[0467] Q = Clip3(0, 65, Qp + 2 * (bS - 1) + (slice_TC_offset_div 2 << 1))(8 - 1050)

[0468] where slice_tc_offset_div2 is the value of the syntax element slice_tc_offset_div2 for the slice containing the sample q0,0.

[0469] The variable tC is derived as follows:

[0470] tC = tC' * (1 << (BitDepthY - 8)) (8 - 1051)

[0471] The following ordered steps apply:

[0472] 1. The variables dp0, dp3, dq0, and dq3 are derived as follows:

[0473] dp0 = Abs(p2,0 - 2 * p1,0 + p0,0) (8 - 1052)

[0474] dp3 = Abs(p2,3 - 2 * p1,3 + p0,3) (8 - 1053)

[0475] dq0 = Abs(q2,0 - 2 * q1,0 + q0,0) (8 - 1054)

[0476] dq3 = Abs(q2,3 - 2 * q1,3 + q0,3) (8 - 1055)

[0477] 2. When both maxFilterLengthP and maxFilterLengthQ are equal to or greater than 3, the variables sp0, sq0, spq0, sp3, sq3, and spq3 are derived as follows:

[0478] sp0 = Abs(p3,0 - p0,0) (8 - 1056)

[0479] sq0 = Abs(q0,0 - q3,0) (8 - 1057)

[0480] spq0 = Abs(p0,0 - q0,0) (8 - 1058)

[0481] sp3 = Abs(p3,3 - p0,3) (8 - 1059)

[0482] sq3 = Abs(q0,3 - q3,3) (8 - 1060)

[0483] spq3 = Abs(p0,3 - q0,3) (8 - 1061)

[0484] 3. The variables sidePisLargeBlk and sideQisLargeBlk are set equal to 0.

[0485] 4. When maxFilterLengthP is greater than 3, sidePisLargeBlk is set equal to 1:

[0486] 5. When maxFilterLengthQ is greater than 3, sideQisLargeBlk is set equal to 1:

[0487] 6. When edgeType is equal to EDGE_HOR and (yCb + yBl) % CtbSizeY is equal to 0, sidePisLargeBlk is set equal to 0.

[0488] 7. Variables dSam0 and dSam3 are initialized to 0.

[0489] 8. When sidePisLargeBlk or sideQisLargeBlk is greater than 0, the following applies:

[0490] a. Variables dp0L and dp3L are derived as follows and maxFilterLengthP is modified:

[0491] – If sidePisLargeBlk is equal to 1, the following applies:

[0492] dp0L = (dp0 + Abs(p5,0 - 2*p4,0 + p3,0) + 1) >> 1 (8 - 1062)

[0493] dp3L = (dp3 + Abs(p5,3 - 2*p4,3 + p3,3) + 1) >> 1 (8 - 1063)

[0494] – Otherwise, the following applies:

[0495] dp0L = dp0 (8 - 1064)

[0496] dp3L = dp3 (8 - 1065)

[0497] maxFilterLengthP = 3 (8 - 1066)

[0498] b. Variables dq0L and dq3L are derived as follows:

[0499] – If sideQisLargeBlk is equal to 1, the following applies:

[0500] dq0L = (dq0 + Abs(q5,0 - 2*q4,0 + q3,0) + 1) >> 1 (8 - 1067)

[0501] dq3L = (dq3 + Abs(q5,3 - 2*q4,3 + q3,3) + 1) >> 1 (8 - 1068)

[0502] – Otherwise, the following applies:

[0503] dq0L = dq0 (8 - 1069)

[0504] dq3L = dq3 (8 - 1070)

[0505] c. The derivation of the variables dpq0L, dpq3L, and dL is as follows:

[0506] dpq0L = dp0L + dq0L (8 - 1071)

[0507] dpq3L = dp3L + dq3L (8 - 1072)

[0508] dL = dpq0L + dpq3L (8 - 1073)

[0509] d. When dL is less than β, the following ordered steps apply:

[0510] i. The variable dpq is set to be equal to 2 * dpq0L.

[0511] ii. The variable sp is set to be equal to sp0, the variable sq is set to be equal to sq0, and the variable spq is set to be equal to spq0.

[0512] iii. The variables p0, p3, q0, and q3 are first initialized to 0 and then modified according to sidePisLargeBlk and sideQisLargeBlk as follows:

[0513] – When sidePisLargeBlk is equal to 1, the following applies:

[0514] p3 = p3,0 (8 - 1074)

[0515] p0 = pmaxFilterLengthP,0 (8 - 1075)

[0516] – When sideQisLargeBlk is equal to 1, the following applies:

[0517] q3 = q3,0 (8 - 1076)

[0518] q0 = qmaxFilterLengthQ,0 (8 - 1077)

[0519] iv. For the sample position (xCb + xBl, yCb + yBl), with the sample values p0, p3, q0, q3, the variables dpq, sp, sq, spq, sidePisLargeBlk, sideQisLargeBlk, β, and tC as inputs, and the output is assigned to the decision dSam0, the decision process for luminance samples specified in entry 8.8.3.6.5 is called.

[0520] v. The variable dpq is set equal to 2 * dpq3L.

[0521] vi. The variable sp is set equal to sp3, the variable sq is set equal to sq3, and the variable spq is set equal to spq3.

[0522] vii. The variables p0, p3, q0, and q3 are first initialized to 0 and then modified according to sidePisLargeBlk and sideQisLargeBlk as follows:

[0523] – When sidePisLargeBlk is equal to 1, the following applies:

[0524] p3 = p3,3 (8 - 1078)

[0525] p0 = pmaxFilterLengthP,3 (8 - 1079)

[0526] – When sideQisLargeBlk is equal to 1, the following applies:

[0527] q3 = q3,3 (8 - 1080)

[0528] q0 = qmaxFilterLengthQ,3 (8 - 1081)

[0529] viii. When for the sample position (Xcb + Xbl, yCb + yBl + 3), edgeType is equal to EDGE_VER or when for the sample position (Xcb + Xbl + 3, yCb + yBl), edgeType is equal to EDGE_HOR, using the sample values p0, p3, q0, q3, the variables dpq, sp, sq, spq, sidePisLargeBlk, sideQisLargeBlk, β, and tC as inputs and assigning the output to the decision dSam3, call the decision process for luminance samples specified in entry 8.8.3.6.5

[0530] 9. The variables dE, dEp, and dEq are derived as follows:

[0531] – If both dSam0 and dSam3 are equal to 1, the variable dE is set equal to 3, dEp is set equal to 1, and dEq is set equal to 1.

[0532] – Otherwise, the following ordered steps apply:

[0533] a. The variables dpq0, dpq3, dp, dq, and d are derived as follows:

[0534] dpq0 = dp0 + dq0 (8 - 1082)

[0535] dpq3 = dp3 + dq3 (8 - 1083)

[0536] dp = dp0 + dp3 (8 - 1084)

[0537] dq = dq0 + dq3 (8 - 1085)

[0538] d = dpq0 + dpq3 (8 - 1086)

[0539] b. The variables dE, dEp, dEq, sidePisLargeBlk, and sideQisLargeBlk are set equal to 0.

[0540] c. When d is less than β and both maxFilterLengthP and maxFilterLengthQ are greater than 2, the following ordered steps apply:

[0541] i. The variable dpq is set equal to 2 * dpq0.

[0542] ii. The variable sp is set equal to sp0, the variable sq is set equal to sq0, and the variable spq is set equal to spq0.

[0543] iii. For the sample position (xCb + xBl, yCb + yBl), with the variables p0, p3, q0, q3 all set equal to 0, the variables dpq, sp, sq, spq, sidePisLargeBlk, sideQisLargeBlk, β, and tC as inputs, and the output assigned to decision dSam0, call the decision process for luminance samples specified in Article 8.8.3.6.5.

[0544] iv. The variable dpq is set equal to 2 * dpq3.

[0545] v. The variable sp is set equal to sp3, the variable sq is set equal to sq3, and the variable spq is set equal to spq3.

[0546] vi. When, for sample position (XCb + Xbl, yCb + yBl + 3), edgeType is equal to EDGE_VER or for sample position (XCb + Xbl + 3, yCb + yBl), edgeType is equal to EDGE_HOR, taking as inputs variables p0, p3, q0, q3, variables dpq, sp, sq, spq, sidePisLargeBlk, sideQisLargeBlk, β, and tC all set equal to 0, and assigning the output to decision dSam0, call the decision process for samples specified in entry 8.8.3.6.5.

[0547] d. When d is less than β, the following ordered steps apply:

[0548] i. Variable dE is set equal to 1.

[0549] ii. When dSam0 is equal to 1 and dSam3 is equal to 1, variable dE is set equal to 2.

[0550] iii. When dp is less than (β + (β >> 1)) >> 3, variable dEp is set equal to 1.

[0551] iv. When dq is less than (β + (β >> 1)) >> 3, variable dEq is set equal to 1.

[0552] Table 8 20 – Deriving Threshold Variables β′ and tC′ from Input Q

[0553] Q 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 β′ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 <![CDATA[t c ′]]> 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Q 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 β′ 7 8 9 10 11 12 13 14 15 16 17 18 20 22 24 26 28 <![CDATA[t c ′]]> 0 1 1 1 1 1 1 1 1 1 2 2 2 2 3 3 3 Q 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 β′ 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 <![CDATA[t C ′]]> 3 4 4 4 5 5 6 6 7 8 9 10 11 13 14 16 18 Q 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 β′ 64 66 68 70 72 74 76 78 80 82 84 86 88 - - <![CDATA[t C ′]]> 20 22 25 28 31 35 39 44 50 56 63 70 79 88 99

[0554] 8.8.3.6.2. Filtering Process for Luma Block Edges

[0555] The inputs to this process are:

[0556] – Picture sample array recPicture,

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

[0558] – Specifying the position (xBl, yBl) of the top - left sample of the current block relative to the top - left sample of the current coding block,

[0559] – Variable edgeType, specifying whether to filter vertical (EDGE_VER) or horizontal (EDGE_HOR) edges,

[0560] – Variables dE, dEp, and dEq containing decisions,

[0561] – Variables maxFilterLengthP and maxFilterLengthQ that contain the maximum filter length,

[0562] – Variable tC.

[0563] The output of this process is the modified picture sample array recPicture.

[0564] Depending on the value of edgeType, the following applies:

[0565] – If edgeType is equal to EDGE_VER, the following ordered steps apply:

[0566] 1. The sample values pi,k and qi,k where i = 0..maxFilterLengthP, j = 0..maxFilterLengthQ, and k = 0..3 are derived as follows:

[0567] qj,k = recPictureL[xCb + xBl + j][yCb + yBl + k] (8 - 1087)

[0568] pi,k = recPictureL[xCb + xBl - i - 1][yCb + yBl + k] (8 - 1088)

[0569] 2. When dE is not equal to 0 and dE is not equal to 3, for each sample position (xCb + xBl, yCb + yBl + k), k = 0..3, the following ordered steps apply:

[0570] a. Using the sample values pi,k, qi,k where i = 0..3, the positions (xPi, yPi) that are set to be equal to (xCb + xB1 - i - 1, yCb + yBl + k) and (xQi, yQi) that are set to be equal to (xCb + xB1 + i, yCb + yB1 + k), decision dE, variables dEp and dEq, and variable tC as inputs, and the number of filtered samples nDp and nDq from each side of the block boundary and the filtered sample values pi' and qj' as outputs, call the filtering process for luminance samples using a short filter as specified in item 8.8.3.6.6.

[0571] b. When nDp is greater than 0, the filtered sample values pi' where i = 0..nDp - 1 replace the corresponding samples within the sample array recPicture as follows:

[0572] recpicture[Xcb + Xbl – i – 1][YCb + YBl + k] = pi' (8 - 1089)

[0573] c. When nDq is greater than 0, the filtered sample values qj' where j = 0..nDp-1 replace the corresponding samples within the sample array recPicture, as follows:

[0574] recPicture[xCb+xBl+j][yCb+yBl+k] = qj' (8-1090)

[0575] 3. When dE equals 3, for each sample position (xCb+xBl, yCb+yBl+k), k = 0..3, the following ordered steps apply:

[0576] a. Using the sample values pi,k and qj,k where i = 0..maxFilterLengthP and j = 0..maxFilterLengthQ, with the positions (xPi, yPi) where i = 0..maxFilterLengthP–1 set equal to (xCb+xBl-i-1,yCb+yBl+k), and the (xQj, yQj) where j = 0..maxFilterLengthQ-1 set equal to (xCb+xBl+j, yCb+yBl+k), the variables maxFilterLengthP, maxFilterLengthQ, and tC as inputs, and the filtered sample values pi' and qj' as outputs, call the filtering process for luma samples using a long filter as specified in entry 8.8.3.6.7.

[0577] b. The filtered sample values pi' where i = 0..maxFilterLengthP-1 replace the corresponding samples within the sample array recPicture, as follows:

[0578] recPicture[xCb+xBl-i-1][yCb+yBl+k] = pi'(8-1091)

[0579] c. The filtered sample values qj' where j = 0..maxFilterLengthQ-1 replace the corresponding samples within the sample array recPicture, as follows:

[0580] recPicture[xCb+xBl+j][yCb+yBl+k] = qj' (8-1092)

[0581] – Otherwise (edgeType equals EDGE_HOR), the following ordered steps apply:

[0582] 1. The sample values pi,k and qi,k where i = 0..maxFilterLengthP, j = 0..maxFilterLengthQ, and k = 0..3 are derived as follows:

[0583] qj,k = recPictureL[xCb + xBl + k][yCb + yBl + j] (8 - 1093)

[0584] pi,k = recPictureL[xCb + xBl + k][yCb + yBl - i - 1](8 - 1094)

[0585] 2. When dE is not equal to 0 and dE is not equal to 3, for each sample position (xCb + xBl + k, yCb + yBl), k = 0..3, the following ordered steps apply:

[0586] a. Using the sample values pi,k, qi,k where i = 3, the settings where i = 0..2d equal to the positions (xPi, yPi) of (xCb + xBl + k, yCb + yBl - i - 1) and (xQi, yQi) equal to (xCb + xBl + k, yCb + yBl + i), the decision dE, the variables dEp and dEq, and the variable tC as inputs, and the number of filtered samples nDp and nDq from each side of the block boundary and the filtered sample values pi' and qj' as outputs, call the filtering process for luma samples using a short filter specified in Clause 8.8.3.6.6.

[0587] b. When nDp is greater than 0, the filtered sample values pi' where i = 0..nDp - 1 replace the corresponding samples in the sample array recPicture as follows:

[0588] recPicture[xCb + xBl + k][yCb + yBl - i - 1] = pi' (8 - 1095)

[0589] c. When nDq is greater than 0, the filtered sample values qj' where j = 0..nDq – 1 replace the corresponding samples in the sample array recPicture as follows:

[0590] recPicture[xCb + xBl + k][yCb + yBl + j] = qj' (8 - 1096)

[0591] 3. When dE is equal to 3, for each sample position (xCb + xBl + k, yCb + yBl), k = 0..3, the following ordered steps apply:

[0592] a. Using the sample values pi,k and qj,k where i = 0..maxFilterLengthP and j = 0..maxFilterLengthQ, with the settings for i = 0..maxFilterLengthP–1 being equal to the positions (xPi, yPi) of (xCb+xCb+xBl+k, yCb+yBl-i-1), and the settings for j = 0..maxFilterLengthQ–1 being equal to (xQj, yQj) of (xCb+xBl+k, yCb+yBl+j), taking the variables maxFilterLengthP, maxFilterLengthQ and the variable tC as inputs, and taking the filtered sample values pi' and qj' as outputs, call the filtering process for luma samples using a long filter as specified in entry 8.8.3.6.7.

[0593] b. Replace the corresponding samples in the sample array recPicture with the filtered sample values where i = 0..maxFilterLengthP-1 as follows:

[0594] recPicture[xCb+xBl+k][yCb+yBl-i-1] = pi' (8-1097)

[0595] c. Replace the corresponding samples in the sample array recPicture with the filtered sample values where j = 0..maxFilterLengthQ-1 as follows:

[0596] recPicture[xCb+xBl+k][yCb+yBl+j] = qj' (8-1098)

[0597] 8.8.3.6.3. Decision process for chroma block edges

[0598] This process is called only if ChromaArrayType is not equal to 0.

[0599] The inputs to this process are:

[0600] – The chroma picture sample array recPicture,

[0601] – Specify the chroma position (xCb, yCb) of the top-left sample of the current chroma coding / decoding block relative to the top-left chroma sample of the current picture,

[0602] – Specify the chroma position (xBl, yBl) of the top-left sample of the current chroma block relative to the top-left sample of the current chroma coding / decoding block,

[0603] – The variable edgeType, which specifies whether to filter vertical edges (EDGE_VER) or horizontal edges (EDGE_HOR).

[0604] – The variable cQpPicOffset, which specifies the picture-level chrominance quantization parameter offset.

[0605] – The variable bS, which specifies the boundary filter strength.

[0606] – The variable maxFilterLengthCbCr.

[0607] The output of this process is

[0608] – The modified variable maxFilterLengthCbCr,

[0609] – The variable tC.

[0610] where for i = 0..maxFilterLengthCbCr and k = 0..1, the values pi and qi are derived as follows:

[0611] – If edgeType is equal to EDGE_VER, then the following applies:

[0612] qi,k = recPicture[xCb + xBl + i][yCb + yBl + k] (8 - 1099)

[0613] pi,k = recPicture[xCb + xBl - i - 1][yCb + yBl + k] (8 - 1100)

[0614] – Otherwise (edgeType is equal to EDGE_HOR), the following applies:

[0615] qi,k = recPicture[xCb + xBl + k][yCb + yBl + i] (8 - 1101)

[0616] pi,k = recPicture[xCb + xBl + k][yCb + yBl - i - 1] (8 - 1102)

[0617] The variables QpQ and QpP are set to be equal to the QpY values of the coding / decoding units of the coding / decoding blocks that respectively contain the samples q0,0 and p0,0.

[0618] The variable QpC is derived as follows:

[0619] If ChromaArrayType is equal to 1, then based on the index qPi derived as follows, the variable QpC is determined as specified in Table 8 - 15:

[0620] qPi = ((QpQ + QpP + 1) >> 1) + cQpPicOffset (8 - 1103)

[0621] – Otherwise (ChromaArrayType > 1), the variable QpC is set to be equal to Min(qPi, 63).

[0622] Note - Depending on whether the filtered chroma component is the Cb or Cr component, the variable cQpPicOffset provides an adjustment to the value of pps_cb_qp_offset or pps_cr_qp_offset. However, to avoid the need to change the amount of adjustment within the picture, the filtering process does not include an adjustment to the value of slice_cb_qp_offset or slice_cr_qp_offset.

[0623] Based on the following derivation of the quantization parameter Q, determine the value of the variable β' as specified in Table 8 - 20:

[0624] Q = Clip3(0, 63, QpC + (slice_beta_offset_div2 << 1)) (8 - 1104)

[0625] where slice_beta_offset_div2 is the value of the syntax element slice_beta_offset_div2 for the slice containing the sample q0,0.

[0626] The variable β is derived as follows:

[0627] β = β' * (1 << (BitDepthc - 8)) (8 - 1105)

[0628] Based on the following derivation of the chroma quantization parameter Q, determine the value of the variable tC' as specified in Table 8 - 20:

[0629] Q = Clip3(0, 65, QPc + 2 * (bS - 1) + (slice_tc_offset_div2 << 1)) (8 - 1106)

[0630] where slice_tc_offset_div2 is the value of the syntax element slice_tc_offset_div2 for the slice containing the sample q0,0.

[0631] The variable tC is derived as follows:

[0632] tC = tC' * (1 << (BitDepthC - 8)) (8 - 1107)

[0633] When maxFilterLengthCbCr is equal to 1 and bS is not equal to 2, maxFilterLengthCbCr is set to be equal to 0.

[0634] When maxFilterLengthCbCr is equal to 3, the following ordered steps apply:

[0635] 1. The variables dpq0, dpq1, dp, dq, and d are derived as follows:

[0636] dp0 = Abs(p2,0 - 2*P1,0 + p0,0) (8 - 1108)

[0637] dp1 = Abs(p2,1 - 2*p1,1 + p0,1) (8 - 1109)

[0638] dq0 = Abs(q2,0 - 2*Q1,0 + q0,0) (8 - 1110)

[0639] dq1 = Abs(q2,1 - 2*Q1,1 + q0,1) (8 - 1111)

[0640] dpq0 = dp0 + dq0 (8 - 1112)

[0641] dpq1 = dp1 + dq1 (8 - 1113)

[0642] dP = dp0 + dp1 (8 - 1114)

[0643] dq = dq0 + dq1 (8 - 1115)

[0644] d = dpq0 + dpq1 (8 - 1116)

[0645] 2. The variables dSam0 and dSam1 are both set to be equal to 0.

[0646] 3. When d is less than β, the following ordered steps are applied:

[0647] a. The variable dpq is set to be equal to 2*dpq0.

[0648] b. For the sample position (xCb + xBl, yCb + yBl), with the sample values p0,0, p3,0, q0,0, and q3,0, the variable dpq, β, and tC as inputs, the output is assigned to the decision dSam0, and the variable dSam0 is derived by calling the decision process for chrominance samples specified in item 8.8.3.6.8.

[0649] c. The variable dpq is set to be equal to 2*dpq1.

[0650] d. The variable dSam1 is modified as follows:

[0651] – If edgeType is equal to EDGE_VER, for the sample position (xCb + xBl, yCb + yBl + 1), with the sample values p0,1, p3,1, q0,1 and q3,1, the variable dpq, β and tC as inputs, assign the output to the decision dSam1, and call the decision process for chroma samples specified in item 8.8.3.6.8.

[0652] – Otherwise (edgeType is equal to EDGE_HOR), for the sample position (xCb + xBl + 1, yCb + yBl), with the sample values p0,1, p3,1, q0,1 and q3,1, the variable dpq, β and tC as inputs, assign the output to the decision dSam1, and call the decision process for chroma samples specified in item 8.8.3.6.8.

[0653] 4. The variable maxFilterLengthCbCr is modified as follows:

[0654] – If dSam0 is equal to 1 and dSam1 is equal to 1, then maxFilterLengthCbCr is set to be equal to 3.

[0655] – Otherwise, maxFilterLengthCbCr is set to be equal to 1.

[0656] 8.8.3.6.4. Filtering Process for Chroma Block Edges

[0657] This process is called only when ChromaArrayType is not equal to 0.

[0658] The inputs to this process are:

[0659] – The chroma picture sample array recPicture,

[0660] – Specify the chroma position (xCb, yCb) of the top-left sample of the current chroma coding / decoding block relative to the top-left chroma sample of the current picture,

[0661] – Specify the chroma position (xBl, yBl) of the top-left sample of the current chroma block relative to the top-left sample of the current chroma coding / decoding block,

[0662] – The variable edgeType, which specifies whether to filter the vertical edge (EDGE_VER) or the horizontal edge (EDGE_HOR),

[0663] – The variable maxFilterLengthCbCr that contains the maximum chroma filter length,

[0664] – variable tC.

[0665] The output of this process is the modified chrominance picture sample array recPicture.

[0666] The derivation of maxK is as follows:

[0667] – If edgeType is equal to EDGE_VER, the following applies:

[0668] maxK = (SubHeightC == 1)? 3 : 1 (8 - 1117)

[0669] – Otherwise (edgeType is equal to EDGE_HOR), the following applies:

[0670] maxK = (SubWidthC == 1)? 3 : 1 (8 - 1118)

[0671] For values of i = 0..maxFilterLengthCbCr and k = 0..maxK, the values pi and qi are derived as follows:

[0672] – If edgeType is equal to EDGE_VER, the following applies:

[0673] qi,k = recPicture[xCb + xBl + i][yCb + yBl + k] (8 - 1119)

[0674] pi,k = recPicture[xCb + xBl - i - 1][yCb + yBl + k] (8 - 1120)

[0675] – Otherwise (edgeType is equal to EDGE_HOR), the following applies:

[0676] qi,k = recPicture[xCb + xBl + k][yCb + yBl + i] (8 - 1121)

[0677] pi,k = recPicture[xCb + xBl + k][yCb + yBl - i - 1] (8 - 1122)

[0678] Depending on the value of edgeType, the following applies:

[0679] – If edgeType is equal to EDGE_VER, for each sample position (xCb + xBl, yCb + yBl + k), k = 0..maxK, the following ordered steps apply:

[0680] 1. Using the variable maxFilterLengthCbCr, the sample values pi,k and qi,k where i = 0..maxFilterLengthCbCr, the positions (xCb + xBl - i - 1, yCb + yBl + k) and (xCb + xBl + i, yCb + yBl + k) where i = 0..maxFilterLengthCbCr - 1, and the variable tC as inputs, and using the filtered sample values pi' and qi' where i = 0..maxFilterLengthCbCr - 1 as outputs, call the process for chrominance samples specified in Clause 8.8.3.6.9.

[0681] 2. Replace the corresponding samples in the sample array recPicture with the filtered sample values pi' and qi' where i = 0..maxFilterLengthCbCr - 1 as follows:

[0682] recPicture[xCb + xBl + i][yCb + yBl + k] = qi′ (8 - 1123)

[0683] recPicture[xCb + xBl - i - 1][yCb + yBl + k] = pi′ (8 - 1124)

[0684] – Otherwise (edgeType equal to EDGE_HOR), for each sample position (xCb + xBl + k, yCb + yBl), k = 0..maxK, the following ordered steps apply:

[0685] 1. Using the variable maxFilterLengthCbCr, the sample values pi,k and qi,k where i = 0..maxFilterLengthCbCr, the positions (xCb + xBl + k, yCb + yBl - i - 1) and (xCb + xBl + k, yCb + yBl + i), and the variable tC as inputs, and using the filtered sample values pi' and qi' as outputs, call the filtering process for chrominance samples specified in Clause 8.8.3.6.9.

[0686] 2. Replace the corresponding samples in the sample array recPicture with the filtered sample values pi' and qi' as follows:

[0687] recPicture[xCb + xBl + k][yCb + yBl + i] = qi′ (8 - 1125)

[0688] ecPicture[xCb + xBl + k][yCb + yBl - i - 1] = pi′ (8 - 1126)

[0689] 8.8.3.6.5. Decision Process for Luminance Samples

[0690] The inputs to this process are:

[0691] – Sample values p0, p3, q0, and q3.

[0692] – Variables dpq, sp, sq, spq, sidePisLargeBlk, sideQisLargeBlk, β, and tC.

[0693] The output of this process is the variable dSam containing the decision.

[0694] The variables sp and sq are modified as follows:

[0695] – When sidePisLargeBlk equals 1, the following applies:

[0696] sp = (sp + Abs(p3 - p0) + 1) >> 1 (8-1127)

[0697] – When sideQisLargeBlk equals 1, the following applies:

[0698] sq = (sq + Abs(q3 - q0) + 1) >> 1 (8-1128)

[0699] The variable sThr is derived as follows:

[0700] – If sidePisLargeBlk equals 1 or sideQisLargeBlk equals 1, the following applies:

[0701] sThr = 3 * β >> 5 (8-1129)

[0702] – Otherwise, the following applies:

[0703] sThr = β >> 3 (8-1130)

[0704] The variable dSam is specified as follows:

[0705] – If all of the following conditions are true, dSam is set to 1:

[0706] – dpq is less than (β >> 2),

[0707] – sp + sq is less than sThr,

[0708] – spq is less than (5 * tC + 1) >> 1,

[0709] – Otherwise, dSam is set to equal 0.

[0710] 8.8.3.6.6. Filtering Process for Luma Samples Using Short Filters

[0711] The inputs to this process are:

[0712] – sample values pi and qi for i = 0..3

[0713] – positions of pi and qi, (xPi, yPi) and (xQi, yQi) for i = 0..2

[0714] – variable dE

[0715] – variables dEp and dEq, containing the decisions for the filtered samples p1 and q1 respectively

[0716] – variable tC

[0717] The outputs of this process are:

[0718] – the number of filtered samples nDp and nDq

[0719] – filtered sample values pi′ and qj′ for i = 0..nDp-1, j = 0..nDq–1

[0720] Depending on the value of dE, the following applies:

[0721] – If the variable dE is equal to 2, then both nDp and nDq are set to be equal to 3, and the following strong filtering applies:

[0722] p0′ = Clip3(p0 - 3*tC, p0 + 3*tC, (p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4) >> 3) (8 - 1131)

[0723] p1′ = Clip3(p1 - 2*tC, p1 + 2*tC, (p2 + p1 + p0 + q0 + 2) >> 2) (8 - 1132)

[0724] p2′ = Clip3(p2 - 1*tC, p2 + 1*tC, (2*p3 + 3*p2 + p1 + p0 + q0 + 4) >> 3) (8 - 1133)

[0725] q0′ = Clip3(q0 - 3*tC, q0 + 3*tC, (p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4) >> 3) (8 - 1134)

[0726] q1′ = Clip3(q1 - 2*tC, q1 + 2*tC, (p0 + q0 + q1 + q2 + 2) >> 2) (8 - 1135)

[0727] q2′ = Clip3(q2 - 1 * tC, q2 + 1 * tC, (p0 + q0 + q1 + 3 * q2 + 2 * q3 + 4) >> 3) (8 - 1136)

[0728] - Otherwise, both nDp and nDq are set equal to 0 and the following weak filtering applies:

[0729] - The following applies:

[0730] Δ = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4(8 - 1137)

[0731] - When Abs(Δ) is less than tC * 10, the following ordered steps apply:

[0732] - The filtered sample values p0’ and q0’ are specified as follows:

[0733] Δ = Clip3(-tC, tC, Δ) (8 - 1138)

[0734] p0′ = Clip1Y(p0 + Δ) (8 - 1139)

[0735] q0′ = Clip1Y(q0 - Δ) (8 - 1140)

[0736] - When dEp equals 1, the filtered sample value p1’ is specified as follows:

[0737] Δp = Clip3(-(tC >> 1), tC >> 1, (((p2 + p0 + 1) >> 1) - p1 + Δ) >> 1) (8 - 1141)

[0738] p1′ = Clip1Y(p1 + Δp) (8 - 1142)

[0739] - When dEq equals 1, the filtered sample value q1’ is specified as follows:

[0740] Δq = Clip3(-(tC >> 1), tC >> 1, (((q2 + q0 + 1) >> 1) - q1 - Δ) >> 1)(8 - 1143)

[0741] q1′ = Clip1Y(q1 + Δq) (8 - 1144)

[0742] - nDp is set equal to dEp + 1 and nDq is set equal to dEq + 1.

[0743] When nDp is greater than 0 and one or more of the following conditions are true, nDp is set equal to 0:

[0744] – The pcm_loop_filter_disabled_flag is equal and the pcm_flag[xP0][yP0] is equal to 1.

[0745] – The cu_transquant_bypass_flag of the coding / decoding unit including the coding / decoding block containing the sample p0 is equal to 1.

[0746] When nDq is greater than 0 and one or more of the following conditions are true, nDq is set to be equal to 0:

[0747] – The pcm_loop_filter_disabled_flag is equal to 1 and the pcm_flag[xQ0][yQ0] is equal to 1.

[0748] – The cu_transquant_bypass_flag of the coding / decoding unit including the coding / decoding block containing the sample q0 is equal to 1.

[0749] 8.8.3.6.7. Filtering Process for Luminance Samples Using Long Filters

[0750] The inputs to this process are:

[0751] – The variables maxFilterLengthP and maxFilterLengthQ,

[0752] – Sample values with i = 0..maxFilterLengthP and j = 0..maxFilterLengthQ,

[0753] – The positions of pi and qj, (xPi, yPi) and (xQj, yQj) with i = 0..maxFilterLengthP - 1 and j = 0..maxFilterLengthQ - 1,

[0754] – The variable tC.

[0755] The outputs of this process are:

[0756] – Filtered sample values pi' and qj' where i = 0..maxFilterLengthP - 1, j = 0..maxFilterLenghtQ - 1.

[0757] The variable refMiddle is derived as follows:

[0758] – If maxFilterLengthP is equal to maxFilterLengthQ and maxFilterLengthP is equal to 5, then the following applies:

[0759] refMiddle = (p4 + p3 + 2 * (p2 + p1 + p0 + q0 + q1 + q2) + q3 + q4 + 8) >> 4 (8 - 1145)

[0760] – Otherwise, if maxFilterLengthP equals maxFilterLengthQ and maxFilterLengthP is not equal to 5, then the following applies:

[0761] refMiddle = (p6 + p5 + p4 + p3 + p2 + p1 + 2 * (p0 + q0) + q1 + q2 + q3 + q4 + q5 + q6 + 8) >> 4 (8 - 1146)

[0762] – Otherwise, if one of the following conditions is true,

[0763] – maxFilterLengthQ equals 7 and maxFilterLengthP equals 5,

[0764] – maxFilterLengthQ equals 5 and maxFilterLengthP equals 7, then the following applies:

[0765] refMiddle = (p4 + p3 + 2 * (p2 + p1 + p0 + q0 + q1 + q2) + q3 + q4 + 8) >> 4 (8 - 1147)

[0766] – Otherwise, if one of the following conditions is true,

[0767] – maxFilterLengthQ equals 5 and maxFilterLengthP equals 3,

[0768] – maxFilterLengthQ equals 3 and maxFilterLengthP equals 5,

[0769] then the following applies:

[0770] refMiddle = (p3 + p2 + p1 + p0 + q0 + q1 + q2 + q3 + 4) >> 3 (8 - 1148)

[0771] – Otherwise, if maxFilterLengthQ equals 7 and maxFilterLengthP equals 3, then the following applies:

[0772] refMiddle = (2 * (p2 + p1 + p0 + q0) + p0 + p1 + q1 + q2 + q3 + q4 + q5 + q6 + 8) >> 4 (8 - 1149)

[0773] – Otherwise, the following applies:

[0774] refMiddle = (p6 + p5 + p4 + p3 + p2 + p1 + 2 * (q2 + q1 + q0 + p0) + q0 + q1 + 8) >> 4 (8 - 1150)

[0775] The derivation of the variables refP and refQ is as follows:

[0776] refP = (pmaxFilterLengtP + pmaxFilterLengthP - 1 + 1) >> 1 (8 - 1151)

[0777] refQ = (qmaxFilterLengtQ + qmaxFilterLengthQ - 1 + 1) >> 1 (8 - 1152)

[0778] The variables fi and tCPDi are defined as follows:

[0779] – If maxFilterLengthP is equal to 7, then the following applies:

[0780] f 0..6 = {59, 50, 41, 32, 23, 14, 5} (8 - 1153)

[0781] tCPD 0..6 = {6, 5, 4, 3, 2, 1, 1} (8 - 1154)

[0782] – Otherwise, if maxFilterLengthP is equal to 5, then the following applies:

[0783] f 0..4 = {58, 45, 32, 19, 6} (8 - 1155)

[0784] tCPD 0..4 = {6, 5, 4, 3, 2} (8 - 1156)

[0785] – Otherwise, the following applies:

[0786] f 0..2 = {53, 32, 11} (8 - 1157)

[0787] tCPD 0..2 = {6, 4, 2} (8 - 1158)

[0788] The variables gj and tCQDj are defined as follows:

[0789] – If maxFilterLengthQ is equal to 7, then the following applies:

[0790] g 0..6 = {59, 50, 41, 32, 23, 14, 5} (8 - 1159)

[0791] tCQD 0..6 = {6, 5, 4, 3, 2, 1, 1} (8 - 1160)

[0792] - Otherwise, if maxFilterLengthQ equals 5, the following applies:

[0793] g 0..4 = {58, 45, 32, 19, 6} (8 - 1161)

[0794] tCQD 0..4 = {6, 5, 4, 3, 2} (8 - 1162)

[0795] - Otherwise, the following applies:

[0796] g 0..2 = {53, 32, 11} (8 - 1163)

[0797] tCQD 0..2 = {6, 4, 2} (8 - 1164)

[0798] The derivation of the filtered sample values pi' and qj' where i = 0..maxFilterLengthP - 1 and j = 0..maxFilterLengthQ - 1 is as follows:

[0799] pi′ = Clip3(pi - (tC * tCPDi) >> 1, pi + (tC * tCPDi) >> 1, (refMiddle * fi + refP * (64 - fi) + 32) >> 6) (8 - 1165)

[0800] qj′ = Clip3(qj - (tC * tCQDj) >> 1, qj + (tC * tCQDj) >> 1, (refMiddle * gj + refQ * (64 - gj) + 32) >> 6) (8 - 1166)

[0801] When one or more of the following conditions are true, the filtered sample value pi' is replaced by the corresponding input sample value pi where i = 0..maxFilterLengthP - 1:

[0802] - pcm_loop_filter_disabled_flag equals 1 and pcm_flag[xPi][yPi] equals 1.

[0803] – The cu_transquant_bypass_flag of the coding / decoding unit including the coding / decoding block containing the sample point pi is equal to 1.

[0804] When one or more of the following conditions are true, the filtered sample value qi’ is replaced by the corresponding input sample value qj where j = 0..maxFilterLengthQ-1:

[0805] – pcm_loop_filter_disabled_flag is equal to 1 and pcm_flag[xQi][yQi] is equal to 1.

[0806] – The cu_transquant_bypass_flag of the coding / decoding unit including the coding / decoding block containing the sample point qi is equal to 1.

[0807] 8.8.3.6.8 Decision process for chroma samples

[0808] The inputs to this process are:

[0809] – Sample values p0, p3, q0 and q3,

[0810] – Variables dpq, β and tC.

[0811] The output of this process is the variable dSam containing the decision.

[0812] The variable dSam is specified as follows:

[0813] – If all of the following conditions are true, dSam is set to be equal to 1:

[0814] – dpq is less than (β >> 2),

[0815] – Abs(p3 - p0) + Abs(q0 - q3) is less than (β >> 3),

[0816] – Abs(p0 - q0) is less than (5 * tC + 1) >> 1.

[0817] Otherwise, dSam is set to be equal to 0.

[0818] 8.8.3.6.9 Filtering process for chroma samples

[0819] This process is called only if ChromaArrayType is not equal to 0.

[0820] The inputs to this process are:

[0821] – Variable maxFilterLength,

[0822] – The chrominance sample values pi and qi where i = 0..maxFilterLengthCbCr,

[0823] – The chrominance positions of pi and qi, where (xPi, yPi) and (xQi, yQi) for i = 0..maxFilterLengthCbCr–1,

[0824] – The variable tC.

[0825] The output of the process is the filtered sample values pi’ and qi’ where i = 0..maxFilterLengthCbCr–1.

[0826] The derivation of the filtered sample values pi’ and qi’ where i = 0..maxFilterLengthCbCr-1 is as follows:

[0827] If maxFilterLengthCbCr equals 3, then the following strong filter applies:

[0828] p0′ = Clip3(p0 - tC, p0 + tC, (p3 + p2 + p1 + 2*p0 + q0 + q1 + q2 + 4) >> 3) (8-1167)

[0829] p1′ = Clip3(p1 - tC, p1 + tC, (2*p3 + p2 + 2*p1 + p0 + q0 + q1 + 4) >> 3) (8-1168)

[0830] p2′ = Clip3(p2 - tC, p2 + tC, (3*p3 + 2*p2 + p1 + p0 + q0 + 4) >> 3) (8-1169)

[0831] q0′ = Clip3(q0 - tC, q0 + tC, (p2 + p1 + p0 + 2*q0 + q1 + q2 + q3 + 4) >> 3) (8-1170)

[0832] q1′ = Clip3(q1 - tC, q1 + tC, (p1 + p0 + q0 + 2*q1 + q2 + 2*q3 + 4) >> 3) (8-1171)

[0833] q2′ = Clip3(q2 - tC, q2 + tC, (p0 + q0 + q1 + 2*q2 + 3*q3 + 4) >> 3)(8-1172)

[0834] – Otherwise, the following weak filter applies:

[0835] Δ = Clip3(-tC, tC, ((((q0 - p0) << 2) + p1 - q1 + 4) >> 3)) (8-1173)

[0836] p0′ = Clip1C(p0+) (8 - 1174)

[0837] q0′ = Clip1C(q0-) (8 - 1175)

[0838] When one or more of the following conditions are true, the filtered sample value pi′, where i = 0..maxFilterLengthCbCr – 1, is replaced by the corresponding input sample value pi:

[0839] – pcm_loop_filter_disabled_flag is equal to 1 and pcm_flag[xPi*SubWidthC][yPi*SubHeightC] is equal to 1.

[0840] – The cu_transquant_bypass_flag of the coding / decoding unit that includes the coding / decoding block containing the sample pi is equal to 1.

[0841] When one or more of the following conditions are true, the filtered sample value qi′, where i = 0..maxFilterLengthCbCr – 1, is replaced by the corresponding input sample value qi:

[0842] – pcm_loop_filter_disabled_flag is equal to 1 and pcm_flag[xQi*SubWidthC][yQi*SubHeightC] is equal to 1.

[0843] – The cu_transquant_bypass_flag of the coding / decoding unit that includes the coding / decoding block containing the sample qi is equal to 1.

[0844] 3. Disadvantages of Existing Implementations

[0845] For chrominance, in the current VVC / VTM deblocking design, the decision and filtering operations are very different from component to component, which may make parallel processing for chrominance components difficult.

[0846] 4. Example Technologies and Embodiments

[0847] It is proposed to tune the deblocking for all chrominance components to ensure that the same deblocking decisions and operations can be applied to different chrominance components. It can enable unified steps for different chrominance components, thus achieving the benefits of high parallelism and throughput.

[0848] It should be noted that the chrominance component can represent the Cb / Cr color component, or the B / R color component in RGB format. In the following description, we take ‘Cb / Cr’ as an example.

[0849] The detailed embodiments described below should be considered as examples for explaining general concepts. These embodiments should not be interpreted narrowly. In addition, these embodiments can be combined in any way.

[0850] In addition to DMVR and BIO mentioned below, the methods described below can also be applied to other decoder motion information derivation techniques.

[0851] 1. It is proposed to apply the same decision result to all chrominance components.

[0852] a. In one example, the decision result can represent the decision on whether to perform deblocking filtering on the chrominance block boundary.

[0853] b. In one example, the decision result can represent the decision on the boundary strength.

[0854] c. In one example, the information of only one color component is used to derive the decisions for two chrominance components.

[0855] i. In one example, the decision made for the Cb component can be applied to the Cr component.

[0856] ii. In one example, the decision made for the Cr component can be applied to the Cb component.

[0857] d. In one example, the chrominance deblocking filter decision step considers both the Cb and Cr components.

[0858] i. In one example, the determination is applied to both color components.

[0859] ii. Alternatively, a first decision is made separately for Cb and Cr, and the final decision applied to the Cb and Cr components is based on the first decision.

[0860] e. In one example, when at least one of the neighboring Cb or Cr blocks has non-zero transform coefficients, the boundary strength for the Cb and Cr blocks is set to 1.

[0861] i. Alternatively, when at least one of the neighboring Cb or Cr blocks has non-zero transform coefficients and no neighboring Cb and Cr blocks are intra-coded, the boundary strength for the Cb and Cr blocks is set to 1.

[0862] f. In one example, when at least one of the neighboring Cb blocks has non-zero transform coefficients and at least one of the neighboring Cr blocks has non-zero transform coefficients, the boundary strength for the Cb and Cr blocks is set to 1.

[0863] i. Alternatively, in addition, when neither of two adjacent Cb blocks has non-zero transform coefficients, or neither of two adjacent Cr blocks has non-zero transform coefficients, the boundary strength applied to the Cb and Cr blocks is set to 0.

[0864] ii. Alternatively, when at least one of the adjacent Cb blocks has non-zero transform coefficients and at least one of the adjacent Cr blocks has non-zero transform coefficients and no adjacent Cb and Cr blocks are intra-coded, the boundary strength for the Cb and Cr blocks is set to 1.

[0865] g. In one example, when the decision to apply the deblocking filter is true for one chrominance component, the decision can be applied to all chrominance components.

[0866] i. Alternatively, when the decision to apply the deblocking filter is true for one color component, the decision can be applied to all color components.

[0867] h. In one example, when the decision to apply the strong deblocking filter is true for one chrominance component, the decision can be applied to all chrominance components.

[0868] i. Alternatively, when the decision to apply the strong deblocking filter is true for one color component, the decision can be applied to all color components.

[0869] 2. It is proposed to apply the same filter to all chrominance components.

[0870] a. In one example, the information of only one color component is used to derive the filter applied to all chrominance components.

[0871] i. In one example, the applied filter can be derived from the signaling of the Cb component.

[0872] ii. In one example, the applied filter can be derived from the signaling of the Cr component.

[0873] b. In one example, the applied filter can be derived from the signaling of both the Cb and Cr components.

[0874] c. In one example, when the boundary strength for the Cb block is not equal to 0 or the boundary strength for the Cr block is not equal to 0, chrominance deblocking can be performed on both the Cb and Cr blocks.

[0875] d. In one example, when the boundary strength for the Cb block is equal to 0 or the boundary strength for the Cr block is equal to 0, chrominance deblocking can be disabled for both the Cb and Cr blocks.

[0876] e. In one example, when the StrongFilterCondition described in Section 2.2.4 is true for one chrominance component, the strong deblocking filter can be applied to all chrominance components.

[0877] i. Alternatively, when the StrongFilterCondition described in Section 2.2.4 is false for one chrominance component, the strong deblocking filter can be disabled for all chrominance components.

[0878] f. In one example, when it is decided to apply the normal deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the normal deblocking filter can be applied to both chrominance components.

[0879] i. Alternatively, the deblocking filter may not be applied to both chrominance components.

[0880] g. In one example, when it is decided to apply the strong / long deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the normal deblocking filter can be applied to both chrominance components.

[0881] i. Alternatively, the deblocking filter may not be applied to both chrominance components.

[0882] ii. Alternatively, the strong / long deblocking filter can be applied to both chrominance components.

[0883] h. In one example, when it is decided to apply the strong / long deblocking filter to one chrominance component and apply the normal deblocking filter to another chrominance component, the strong / long deblocking filter should be applied to both chrominance components.

[0884] i. Alternatively, the normal deblocking filter can be applied to both chrominance components

[0885] 3. It is proposed that the deblocking parameters (i.e., β and tC) for all chrominance components can be set the same

[0886] a. In one example, β and tC for all chrominance components can follow one chrominance component.

[0887] b. In one example, β and tC for all chrominance components can depend on the average of pps_cb_qp_offset or pps_cr_qp_offset.

[0888] c. In one example, β and tC for all chrominance components can depend on pps_joint_cbcr_qp_offset.

[0889] d. In one example, β and tC for all chrominance components can depend on the average of (pps_cb_qp_offset + slice_cb_qp_offset) and (pps_cr_qp_offset + slice_cr_qp_offset).

[0890] e. In one example, β and tC for all chrominance components can depend on slice_joint_cbcr_qp_offset.

[0891] 4. The method proposed above can be applied under specific conditions.

[0892] a. In one example, the conditions are that the color format is 4:2:0 and / or 4:2:2.

[0893] i. Alternatively, in addition, for the 4:4:4 color format, how to apply the deblocking filter to two color chrominance components can follow the current design.

[0894] b. In one example, an indication of the use of the above method can be signaled at the sequence / picture / strip / slice / tile / video region level (e.g., in the SPS / PPS / picture header / strip header).

[0895] 5. Additional embodiments

[0896] 5.1 Embodiment #1

[0897] Modified boundary strength

[0898]

[0899]

[0900] When bS is equal to 2 or when bS is equal to 1 when a large block boundary is detected, chrominance deblocking is performed.

[0901] 5.2 Embodiment #2

[0902] If ChromaArrayType = 1, then the variable Qp is determined based on the index qPi derived as follows, as specified in Table 8-15 C :

[0903] qPi = ((Qp Q + Qp P + 1) >> 1) + ((pps_cb_qp_offset + pps_cr_qp_offset + 1) >> 1)

[0904] or qPi = ((Qp Q + Qp P+pps_cb_qp_offset + pps_cr_qp_offset + 1) >> 1)

[0905] Otherwise (ChromaArrayType is greater than 1), the variable Qp C is set to be equal to Min(qPi, 63).

[0906] Based on the quantization parameter Q derived as follows, determine the value of the variable β′ as specified in Table 8 - 20:

[0907] Q = Clip3(0, 63, Qp C +(slice_beta_offset_div2 << 1))

[0908] where slice_beta_offset_div2 is the value of the syntax element slice_beta_offset_div2 for the slice containing the sample q 0,0

[0909] The variable β is derived as follows:

[0910] β = β′ * (1 << (BitDepth C - 8))

[0911] The decisions for the long / normal / non - deblocking filter and the unified deblocking filter for Cb or Cr following the VVC draft 5 follow the table below.

[0912]

[0913]

[0914] 5.3 Example #3

[0915] If ChromaArrayType = 1, determine the variable Qp based on the index qPi derived as follows, as specified in Table 8 - 15 C :

[0916] qPi = ((Qp Q + Qp P + 1) >> 1) + ((pps_cb_qp_offset + pps_cr_qp_offset + 1) >> 1)

[0917] or qPi = ((Qp Q + Qp P + pps_cb_qp_offset + pps_cr_qp_offset + 1) >> 1)

[0918] ​Otherwise (ChromaArrayType is greater than 1), the variable Qp C is set to be equal to Min(qPi, 63).

[0919] Based on the quantization parameter Q derived as follows, the value of the variable β′ is determined as specified in Table 8-20:

[0920] Q = Clip3(0, 63, Qp C +(slice_beta_offset_div2 << 1))

[0921] where slice_beta_offset_div2 is the value of the slice syntax element slice_beta_offset_div2 that includes the sample q 0,0 of the strip.

[0922] The variable β is derived as follows:

[0923] β = β′ * (1 << (BitDepth C - 8))

[0924] The decision for the long / normal / none deblocking filter and the unified deblocking filter for Cb or Cr following VVC Draft 5 follows the table below.

[0925]

[0926]

[0927] 6. Example implementation of the disclosed technology

[0928] Figure 5 is a block diagram of a video processing apparatus 500. The apparatus 500 can be used to implement one or more methods described herein. The apparatus 500 can be implemented in a smart phone, a tablet computer, a computer, an Internet of Things (IoT) receiver, etc. The apparatus 500 can include one or more processors 502, one or more memories 504, and video processing hardware 506. The (multiple) processors 502 can be configured to implement one or more methods described in this document. The (multiple) memories 504 can be used to store data and code for implementing the methods and techniques described herein. In a hardware circuit, the video processing hardware 506 can be used to implement some of the techniques described in this document and can be partially or fully part of the processor 502 (e.g., a graphics processing unit core GPU or other signaling processing circuit).

[0929] In this document, the term "video processing" may refer to video encoding, video decoding, video compression, or video decompression. For example, a video compression algorithm may be applied during the conversion from the pixel representation of a video to the corresponding bitstream representation or vice versa. For example, the bitstream representation of the current video block may correspond to bits that are co-located within the bitstream or distributed at different locations, as defined by the syntax. For example, a macroblock may be encoded based on the transform and codec error residual values, or may be encoded using bits in the header and bits in other regions of the bitstream.

[0930] It should be understood that by allowing the use of the disclosed techniques of this document, the disclosed methods and techniques are beneficial to video encoder and / or decoder embodiments, which are combined with video processing devices such as smartphones, laptops, desktop computers, and similar devices.

[0931] Figure 6 is a flowchart of an example method 600 of video processing. At 610, method 600 includes performing a conversion between a current video unit and a bitstream representation of the current video unit, wherein, during the conversion, a decision is made to selectively apply the same filtering operation to multiple color components of the current video unit, and wherein the decision to apply the filtering operation is based on a binary value that satisfies at least one condition.

[0932] Some embodiments may be described using the following entry-based format.

[0933] 1. A method of visual media processing, comprising: performing a conversion between a current video unit and a bitstream representation of the current video unit, wherein, during the conversion, a decision is made to selectively apply the same filtering operation to multiple color components of the current video unit, and wherein the decision to apply the filtering operation is based on a binary value that satisfies at least one condition.

[0934] 2. The method according to entry 1, wherein the same filtering operation is applied to the boundaries of the current video unit.

[0935] 3. The method according to entry 1, wherein at least one condition relates to the length of the boundary of the current video unit.

[0936] 3. The method according to entry 1, wherein at least one condition is associated with only one of the multiple color components.

[0937] 4. The method according to entry 1, wherein at least one condition is associated with all of the multiple color components.

[0938] 5. The method according to entry 1, wherein applying the same filtering operation to the multiple color components of the current video unit is based on the individual results of making the decision to apply the same filtering operation to each of the multiple color components.

[0939] 6. The method according to item 1 further includes: once it is detected that at least one color component of a video unit adjacent to the current video unit has a non-zero transform coefficient, setting the boundary strength value of the current video unit to a predefined number.

[0940] 7. The method according to item 1 further includes: once it is detected that at least one color component of a video unit adjacent to the current video unit has a non-zero transform coefficient and the at least one color component is not intra-coded, setting the boundary strength value of the current video unit to a predefined number.

[0941] 8. The method according to item 1 further includes: once it is detected that a plurality of color components of a video unit adjacent to the current video unit have non-zero transform coefficients and none of the plurality of color components is intra-coded, setting the boundary strength value of the current video unit to a predefined number.

[0942] 9. The method according to item 1, wherein when the decision to apply a filtering operation is true for one of the plurality of color components of the current video unit, the filtering operation is applied to each of the plurality of color components of the current video unit.

[0943] 10. The method according to item 1, wherein information related to one of the plurality of color components of the current video unit is used to derive a filtering operation related to the plurality of color components of the current video unit.

[0944] 11. The method according to item 1, wherein when the boundary strength value of the current video unit is not equal to the predefined number, the filtering operation is enabled for the plurality of color components of the current video unit.

[0945] 12. The method according to item 1, wherein when the boundary strength value of the current video unit is not equal to the predefined number, the filtering operation is disabled for each of the plurality of color components of the current video unit.

[0946] 13. The method according to item 1, wherein at least one condition is related to the color format.

[0947] 14. The method according to item 1, wherein the color format is 4:2:0 or 4:2:2.

[0948] 15. The method according to item 1, wherein the plurality of components of the current video unit are chrominance components.

[0949] 16. The method according to item 1, wherein the plurality of components of the current video unit are in the Cb, Cr format.

[0950] 17. The method according to item 1, wherein the plurality of components of the current video unit are in the RGB format.

[0951] 19. An apparatus in a video system, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method according to any one of items 1 to 17.

[0952] 20. A computer program product stored on a non-transitory computer-readable medium, the computer program product comprising program code for performing the method according to any one of items 1 to 17.

[0953] Figure 7 is a flowchart of an example method 700 for video processing. Method 700 includes, at 702, deriving at least one decision result associated with a decision in a chrominance deblocking filter decision process for a conversion between a video processing unit domain of a video and a bitstream representation of the video processing unit; at 704, applying the same decision result from the at least one decision result to all chrominance components of the video processing unit; at 706, performing the conversion based on the same decision result.

[0954] In some examples, the chrominance components of the video processing unit include a first chrominance component and a second chrominance component.

[0955] In some examples, when the video processing unit is in YCbCr format, the first chrominance component is the Cb color component and the second chrominance component is the Cr color component.

[0956] In some examples, when the video processing unit is in RGB format, the first chrominance component is the G color component and the second chrominance component is the B color component.

[0957] In some examples, the decision result indicates a decision on whether to perform a deblocking filter on a chrominance block boundary.

[0958] In some examples, the decision result indicates a decision on boundary strength.

[0959] In some examples, the decision for both the first and second chrominance components is derived using information from only one color component.

[0960] In some examples, the decision made for the first chrominance component is applied to the second chrominance component.

[0961] In some examples, the decision made for the second chrominance component is applied to the first chrominance component.

[0962] In some examples, the decision for both the first and second chrominance components is derived using information from both the first and second chrominance components.

[0963] In some examples, the decision is applied to both the first and second chrominance components.

[0964] In some examples, the decision includes a first decision and a final decision, where the first decision is made for the first and second chrominance components respectively, and the final decision applied to both the first and second chrominance components is based on the first decision.

[0965] In some examples, when at least one of the neighboring blocks of the first or second chrominance component has non-zero transform coefficients, the boundary strength of the first and second chrominance component blocks is set to 1.

[0966] In some examples, when at least one of the neighboring blocks of the first or second chrominance component has non-zero transform coefficients and no neighboring blocks of the first and second chrominance components are intra-coded, the boundary strength of the first and second chrominance component blocks is set to 1.

[0967] In some examples, when at least one of the neighboring blocks of the first or second chrominance component has non-zero transform coefficients and at least one of the neighboring blocks of the second chrominance component has non-zero transform coefficients, the boundary strength of the first and second chrominance component blocks is set to 1.

[0968] In some examples, when neither of the neighboring blocks of the first chrominance component has non-zero transform coefficients, or neither of the neighboring blocks of the second chrominance component has non-zero transform coefficients, the boundary strength of the first and second chrominance component blocks is set to 0.

[0969] In some examples, when at least one of the neighboring blocks of the first or second chrominance component has non-zero transform coefficients, at least one of the neighboring blocks of the second chrominance component has non-zero transform coefficients, and no neighboring blocks of the first and second chrominance components are intra-coded, the boundary strength of the first and second chrominance component blocks is set to 1.

[0970] In some examples, the decision result indicates whether to apply a deblocking filter to one chrominance component. When the decision indicates to apply a deblocking filter to one chrominance component, the decision is applied to all chrominance components.

[0971] In some examples, the decision result indicates whether to apply a deblocking filter to one color component. When the decision indicates to apply a deblocking filter to one color component, the decision is applied to all color components.

[0972] In some examples, the decision result indicates whether to apply a strong deblocking filter to one chrominance component. When the decision indicates to apply a strong deblocking filter to one chrominance component, the decision is applied to all chrominance components.

[0973] In some examples, the decision result indicates whether to apply a strong deblocking filter to a color component. When the decision indicates to apply a strong deblocking filter to a color component, that decision is applied to all color components.

[0974] Figure 8 is a flowchart of an example method 800 for video processing. The method 800 includes, at 802, deriving at least one deblocking filter associated with the chrominance deblocking filter process of a video processing unit in connection with the conversion between the video processing unit and the bitstream representation of the video processing unit; at 804, applying the same deblocking filter from the at least one deblocking filter to all chrominance components of the video processing unit; and at 806, performing the conversion based on the same deblocking filter.

[0975] In some examples, the chrominance components of a video processing unit include a first chrominance component and a second chrominance component.

[0976] In some examples, when the video processing unit is in YCbCr format, the first chrominance component is the Cb color component and the second chrominance component is the Cr color component.

[0977] In some examples, when the video processing unit is in RGB format, the first chrominance component is the G color component and the second chrominance component is the B color component.

[0978] In some examples, a deblocking filter applied to all chrominance components is derived using information of only one color component.

[0979] In some examples, the deblocking filter is derived from the signaling of the first chrominance component.

[0980] In some examples, the deblocking filter is derived from the signaling of the second chrominance component.

[0981] In some examples, the deblocking filter is derived from the signaling of both the first and second chrominance components.

[0982] In some examples, when the boundary strength for the first chrominance component block is not equal to 0 or the boundary strength for the second chrominance component block is not equal to 0, a chrominance deblocking filter process is performed on both the first and second chrominance components.

[0983] In some examples, when the boundary strength for the first chrominance component block is equal to 0 or the boundary strength for the second chrominance component block is equal to 0, the chrominance deblocking filter process is disabled for both the first and second chrominance components.

[0984] In some examples, when the indication for strong deblocking filter is true for one chrominance component, the strong deblocking filter is applied to all chrominance components, where the indication is StrongFilterCondition.

[0985] In some examples, when the indication for strong deblocking filter is false for one chrominance component, the strong deblocking filter is disabled for all chrominance components, where the indication is StrongFilterCondition.

[0986] In some examples, when it is decided to apply the normal deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the normal deblocking filter is applied to both chrominance components.

[0987] In some examples, when it is decided to apply the normal deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the deblocking filter is not applied to both chrominance components.

[0988] In some examples, when it is decided to apply the strong or long deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the normal deblocking filter is applied to both chrominance components.

[0989] In some examples, when it is decided to apply the strong or long deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the deblocking filter is not applied to both chrominance components.

[0990] In some examples, when it is decided to apply the strong or long deblocking filter to one chrominance component and not apply the deblocking filter to another chrominance component, the strong or long deblocking filter is applied to both chrominance components.

[0991] In some examples, when it is decided to apply the strong or long deblocking filter to one chrominance component and apply the normal deblocking filter to another chrominance component, the strong or long deblocking filter is applied to both chrominance components.

[0992] In some examples, when it is decided to apply the strong or long deblocking filter to one chrominance component and apply the normal deblocking filter to another chrominance component, the normal deblocking filter is applied to both chrominance components.

[0993] Figure 9is a flowchart of an example method 900 for video processing. The method 900 includes, at 902, deriving deblocking parameters associated with a chrominance deblocking filter decision process and / or a chrominance deblocking filtering process of a video processing unit for a conversion between the video processing unit of a video and a bitstream representation of the video processing unit; at 904, applying the same deblocking parameters from the deblocking parameters to all chrominance components of the video processing unit; and at 906, performing the conversion based on the same deblocking parameters.

[0994] In some examples, the chrominance components of the video processing unit include a first chrominance component and a second chrominance component.

[0995] In some examples, when the video processing unit is in YCbCr format, the first chrominance component is the Cb color component and the second chrominance component is the Cr color component.

[0996] In some examples, when the video processing unit is in RGB format, the first chrominance component is the G color component and the second chrominance component is the B color component.

[0997] In some examples, the deblocking parameters include at least one of parameters β and t involved in a chrominance deblocking filter decision process and a chrominance deblocking filtering process, where parameters β and t are derived based on quantization parameters of blocks on both sides of a boundary. C C .

[0998] In some examples, parameters β and t for all chrominance components C follow one chrominance component.

[0999] In some examples, parameters β and t for all chrominance components C depend on an average of pps_cb_qp_offset or pps_cr_qp_offset, where pps_cb_qp_offset and pps_cr_qp_offset are syntax elements that respectively specify offsets of luminance quantization parameters for deriving chrominance quantization parameters of Cb and Cr components.

[1000] In some examples, parameters β and t for all chrominance components depend on pps_joint_cbcr_qp_offset, where pps_jointcbcr_qp_offset is a syntax element that specifies an offset of a luminance quantization parameter for deriving a joint chrominance quantization parameter.

[1001] ​In some examples, the parameters β and tC for all chrominance components depend on the average of (pps_cb_qp_offset + slice_cb_qp_offset) and (pps_cr_qp_offset + slice_cr_qp_offset); where pps_cb_qp_offset and pps_cr_qp_offset are syntax elements signaled in the sequence parameter set that specify the offsets of the luma quantization parameter used to derive the chrominance quantization parameters for the Cb and Cr components, respectively.

[1002] Where slice_cb_qp_offset and slice_cr_qp_offset are syntax elements signaled in the slice header that specify the differences added to the values of pps_cb_qp_offset and pps_cr_qp_offset, respectively, when determining the chrominance quantization parameter values for the Cb and Cr components.

[1003] In some examples, the parameters β and tC for all chrominance components depend on slice_joint_cbcr_qp_offset, where slice_joint_cbcr_qp_offset is a syntax element signaled in the slice header that specifies the difference added to pps_joint_cbcr_qp_offset_value when determining the joint chrominance quantization parameter value, and pps_joint_cbcr_qp_offset is a syntax element signaled in the sequence parameter set that specifies the offset of the luma quantization parameter used to derive the joint chrominance quantization parameter.

[1004] In some examples, whether to apply the chrominance deblocking filter decision process and / or the chrominance deblocking filter process depends on specific conditions.

[1005] In some examples, the condition is that the color format of the video processing unit is 4:2:0 and / or 4:2:2.

[1006] In some examples, an indication of the use of the chrominance deblocking filter decision process and / or the chrominance deblocking filter process is signaled at least at one of the sequence, picture, slice, slice group, slice, tile, and video region levels.

[1007] In some examples, an indication of the use of the chrominance deblocking filter decision process and / or the chrominance deblocking filter process is signaled in at least one of the video parameter set (VPS), sequence parameter set (SPS), picture parameter set (PPS), picture header, slice header, and slice group header.

[1008] In some examples, the video processing unit includes at least one of a codec unit (CU), a prediction unit (PU), and a transform unit (TU).

[1009] In some examples, transform a video processing unit that generates a video from a bitstream representation.

[1010] In some examples, transform to generate a bitstream representation from a video processing unit of a video.

[1011] Figure 10 is a flowchart of an example method 1000 for video processing. The method 1000 includes, at 1002, determining, based on one or more quantization parameters (QPs) associated with a second color component of a current block of a video, one or more deblocking parameters associated with a first color component involved in a deblocking filter process for the conversion between the first color component of the current block of the video and the bitstream representation of the first color component of the current block of the video; and at 1004, performing the conversion based on the determined deblocking parameters.

[1012] In some examples, the current block of the video includes one luminance component and two chrominance components, and the first color component is one of the two chrominance components and the second color component is the luminance component.

[1013] In some examples, when the video is in YCbCr format, the first color component is the Cb color component or the Cr color component, and the second color component is the Y color component.

[1014] In some examples, when the video is in RGB format, the first color component is the R color component or the B color component, and the second color component is the G color component.

[1015] In some examples, the deblocking parameters include at least one of the parameters β and t involved in the deblocking filter process C among others.

[1016] In some examples, the deblocking parameters of the first color component depend on the QP derived from the luminance QPs of both the P and Q blocks.

[1017] In some examples, the deblocking parameters of the first color component depend on the chrominance QP table value with Qp Q as the table index, where Qp Q is the luminance QP value of the Q block.

[1018] In some examples, the deblocking parameters of the first color component depend on the chrominance QP table value with Qp P as the table index, where Qp P is the luminance QP value of the P block.

[1019] Figure 11is a flowchart of an example method 1100 for video processing. Method 1100 includes, at 1102, for the conversion between the first chrominance component of the current block of the video and the bitstream representation of the first chrominance component of the video, applying one or more processes or parameters to the chroma deblocking process of the first chrominance component to modify the chroma deblocking process of the first chrominance component; and at 1104, performing the conversion based on the modified chroma deblocking process.

[1020] In some examples, one or more processes include a position-dependent cropping process depending on a cropping function.

[1021] In some examples, the cropping function is defined as y = clip(a, b, x), where x is the sample value before cropping, y is the sample value after cropping, and a and b give the lower and upper limits of y.

[1022] In some examples, the cropping function clip(a, b, x) is defined as (x <= a? a : (x >= b? b : x)).

[1023] In some examples, the cropping function clip(a, b, x) is defined as (x < a? a : (x > b? b : x)).

[1024] In some examples, a and b vary based on the sample position.

[1025] In some examples, a is defined as f(x, t C )), where x is the input sample value and t C is a deblocking parameter.

[1026] In some examples, f(x, t C ) is defined as x – (t C * n), where n is a variable.

[1027] In some examples, f(x, t C ) is defined as x – (t C * n >> 1), where n is a variable.

[1028] In some examples, b is defined as g(x, t C ), where x is the input sample value and t C is a deblocking parameter.

[1029] In some examples, g(x, t C ) is defined as x + (t C * m), where m is a variable.

[1030] In some examples, g(x, t C ) is defined as x + (t C * m >> 1), where m is a variable.

[1031] In some examples, m and / or n vary based on the sample position.

[1032] In some examples, a larger m and / or n is applied to samples closer to the edge compared to samples farther from the edge.

[1033] In some examples, the same value of m and / or n is applied to two samples having positions symmetric with respect to the deblocking boundary.

[1034] In some examples, m and / or n are integers.

[1035] In some examples, m and / or n depend on at least one of the following:

[1036] a. Video content, including screen content or natural content;

[1037] b. A message signaled in at least one of a DPS, SPS, VPS, PPS, APS, picture header, slice header, slice group header, largest coding unit (LCU), coding unit (CU), LCU row, group of LCUs, TU, PU, block, and video coding unit;

[1038] c. The position of at least one of a CU, PU, TU, block, or video coding unit;

[1039] d. The block dimensions of the current block and / or its neighboring blocks;

[1040] e. The block shape of the current block and / or its neighboring blocks;

[1041] f. An indication of a color format, the color format including at least one of 4:2:0, 4:4:4, RGB, or YUV;

[1042] g. A coding tree structure, including at least one of a binary tree or a single tree;

[1043] h. At least one of a slice type, slice group type, or picture type;

[1044] i. A color component, including Cb or Cr;

[1045] j. A temporal layer ID;

[1046] k. A profile, level, tier of a standard.

[1047] In some examples, m and / or n are signaled to the decoder.

[1048] In some examples, one or more parameters include a quantization parameter (Qp) offset related to a luminance level used in a luminance deblocking process.

[1049] In some examples, the Qp offset is derived based on the reconstructed average luminance level.

[1050] In some examples, during chroma deblocking, the Qp offset is added to Qp either before or after chroma Qp mapping.

[1051] Figure 12 is a flowchart of an example method 1200 for video processing. Method 1200 includes, at 1202, for the conversion between the first color component of the current block of a video and the bitstream representation of the first color component of the current block of the video, determining a deblocking process to be applied to the first color component based on the corresponding sample values of the second color component of the current block of the video; and at 1204, performing the conversion based on the determined deblocking process for the first color component.

[1052] In some examples, the current block of a video includes one luminance component and two chrominance components, and the first color component is one of the two chrominance components, and the second color component is the luminance component.

[1053] In some examples, when the video is in YCbCr format, the first color component is the Cb color component or the Cr color component, and the second color component is the Y color component.

[1054] In some examples, when the video is in RGB format, the first color component is the R color component or the B color component, and the second color component is the G color component.

[1055] In some examples, the deblocking process for the chrominance component depends on the reconstructed luminance level.

[1056] In some examples, the deblocking process for the chrominance component depends on the reconstructed average luminance level of the corresponding luminance samples.

[1057] Figure 13 is a flowchart of an example method 1300 for video processing. Method 1300 includes, at 1302, for the conversion between a large block of a video and the bitstream representation of the large block of the video, determining a deblocking filter to be executed on the large block boundary based on deblocking conditions and one or more deblocking filter conditions; and at 1304, performing the conversion based on the determined deblocking filter.

[1058] In some examples, when the deblocking conditions are met but the stronger deblocking filter conditions are not met, a weak deblocking filter is directly executed on the large block boundary.

[1059] In some examples, the deblocking conditions for the large block depend on whether the samples at the P side or Q side belong to the large block and / or the values of the samples and a first threshold β involved in the deblocking filter decision process.

[1060] In some examples, the stronger deblocking filter condition for a large block depends on the sample value, a first threshold β and a second threshold t involved in the deblocking filter decision process C 。

[1061] In some examples, when the deblocking condition is satisfied and the stronger deblocking filter condition is not satisfied, but the strong deblocking filter condition is satisfied, a strong deblocking filter is applied at the large block boundary

[1062] In some examples, the deblocking condition for a large block depends on whether the samples at the P side or Q side belong to the large block and / or the sample values and a first threshold β involved in the deblocking filter decision process

[1063] In some examples, the stronger deblocking filter condition for a large block depends on the sample value, a first threshold β and a second threshold t involved in the deblocking filter decision process C 。

[1064] In some examples, the strong deblocking filter condition for a large block depends on the sample value and a first threshold β involved in the deblocking filter decision process

[1065] In some examples, whether and how to apply the determination step, the application step, and / or the execution step is based on specific conditions

[1066] In some examples, the condition is that the color format is 4:2:0 and / or 4:2:2

[1067] In some examples, for the 4:4:4 color format, how to apply the deblocking filter to the two color chrominance components follows the current design

[1068] In some examples, an indication of the use of the determination step, the application step, and / or the execution step is signaled at at least one of the levels of sequence, picture, slice, tile, chunk, video regions including SPS, PPS, picture header, and slice header

[1069] In some examples, the use of the determination step, the application step, and / or the execution step is based on at least one of the following:

[1070] i. Video content, including screen content or natural content;

[1071] ii. A message signaled in at least one of DPS, SPS, VPS, PPS, APS, picture header, slice header, tile group header, largest coding unit (LCU), coding unit (CU), LCU row, group of LCUs, TU, PU block, and video coding unit;

[1072] iii. The position of at least one of CU, PU, TU, block, and video coding unit

[1073] iv. Coding and decoding modes of blocks containing samples along an edge;

[1074] v. Transformation matrices applied to blocks containing samples along an edge;

[1075] vi. Block dimensions of the current block and / or its neighboring blocks;

[1076] vii. Block shapes of the current block and / or its neighboring blocks;

[1077] viii. Indications of color formats, including 4:2:0, 4:4:4, RGB, or YUV

[1078] ix. Coding and decoding tree structures, including dual trees or single trees;

[1079] x. Strip, slice group type, and / or picture type;

[1080] xi. Color components, including Cb or Cr

[1081] xii. Temporal layer ID;

[1082] xiii. Profiles, levels, and tiers of standards

[1083] In some examples, the conversion generates color components of a video from a bitstream representation.

[1084] In some examples, the conversion generates blocks of a video from a bitstream representation.

[1085] In some examples, the conversion generates a bitstream representation from color components of a video.

[1086] In some examples, the conversion generates a bitstream representation from blocks of a video.

[1087] The disclosed and other solutions, examples, embodiments, modules, and functional operations described in this document can be implemented in digital electronic circuits, or in computer software, firmware, or hardware (including the structures disclosed herein and their structural equivalents), or in combinations of one or more of them. The disclosed embodiments and other embodiments can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer-readable medium for execution by, or to control the operation of, a 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 affecting a machine-readable propagated signal, or a combination of one or more of them. The term "data processing apparatus" encompasses all apparatus, devices, and machines for processing data, including, by way of example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the apparatus can also include code that creates an execution environment for the computer programs being discussed, e.g., code constituting processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them. A propagated signal is an artificially generated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal, which is generated to encode information for transmission to a suitable receiver apparatus.

[1088] A computer program (also called a program, software, software application, script, or code) can be written in any form of programming language (including a compiled or interpreted language) and 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 part 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, or in multiple coordinated files (e.g., files that store one or more modules, subroutines, or portions of code). A computer program can be deployed to be executed on one or more computers that are located at one site or distributed across multiple sites and interconnected by a communication network.

[1089] The processes and logical 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. These processes and logical flows can also be performed by, or 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).

[1090] For example, a processor suitable for executing a computer program includes general and special purpose microprocessors, as well as any one or more processors of any kind of digital computer. Generally speaking, 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 storage devices for storing instructions and data. Usually, a computer will also include one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks or optical disks, or is operatively coupled to receive data from or transfer data to one or more mass storage devices, or both. However, a computer does not necessarily 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, for example, semiconductor memory devices such as EPROM, EEPROM and flash memory devices; magnetic disks, such as internal hard disks or removable hard disks; magneto-optical disks; and CD ROM and DVD ROM disks. The processor and the memory may be supplemented by, or incorporated in, special logic circuitry.

[1091] Although this patent document contains many details, it should not be construed as limiting any subject matter or the scope of any claims, but rather as a description of specific features that are specific to particular embodiments of a particular technology. Certain features described in the context of individual embodiments in this patent document may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented separately or in any suitable sub-combination in multiple embodiments. Additionally, although certain features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination may in some cases be removed from that combination, and the claimed combination may relate to a sub-combination or a variation of a sub-combination.

[1092] Similarly, although operations are shown in the drawings in a particular order, this should not be construed as requiring that such operations be performed in a sequential order or the particular order shown, or that all of the operations shown be performed to achieve a desired result. Additionally, the partitioning of various system components described in the embodiments of this patent document should not be construed as requiring such partitioning in all embodiments.

[1093] Only a few embodiments and examples have been 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 for processing video, comprising: Based on one or more quantization parameters QP associated with a second color component of the current block of the video, determining one or more deblocking parameters related to the first color component involved in the deblocking filter process for the conversion between the first color component of the current block of the video and the bitstream of the first color component of the current block of the video; And Performing the conversion based on the determined deblocking parameters; Wherein, the deblocking process of the first color component is determined based on the sample values corresponding to the second color component; Wherein, the deblocking process for the first color component depends on the reconstructed luminance level of the corresponding luminance sample or depends on the average luminance level of the reconstructed luminance sample, wherein the first color component is a chrominance component and the second color component is a luminance component.

2. The method according to claim 1, wherein the current block of the video comprises one luminance component and two chrominance components, and the first color component is one of the two chrominance components and the second color component is the luminance component.

3. The method according to claim 2, wherein when the video is in YCbCr format, the first color component is the Cb color component or the Cr color component and the second color component is the Y color component.

4. The method according to claim 2, wherein when the video is in RGB format, the first color component is the R color component or the B color component and the second color component is the G color component.

5. The method according to any one of claims 1-4, wherein the deblocking parameters include at least one of the parameters β and t involved in the deblocking filter process C among them.

6. The method according to any one of claims 1-4, wherein the deblocking parameters for the first color component depend on the QP derived from the luminance QP of both the P block and the Q block.

7. The method according to any one of claims 1-4, wherein the deblocking parameter for the first color component depends on the chrominance QP table value with Qp Q as the table index, where Qp Q is the luminance QP value of the Q block.

8. The method according to any one of claims 1-4, wherein the deblocking parameter for the first color component depends on the chrominance QP table value with Qp P as the table index, where Qp P is the luma QP value of the P block.

9. A method for processing video, comprising: Applying one or more processes or parameters to the chrominance deblocking process of the first chrominance component for the conversion between the first chrominance component of the current block of the video and the bitstream of the first chrominance component of the video to modify the chrominance deblocking process of the first chrominance component; And Performing the conversion based on the modified chrominance deblocking process; Wherein, the deblocking process of the first chrominance component is determined based on the sample values corresponding to the luminance component of the current block; Wherein, the deblocking process for the first chrominance component depends on the reconstructed luminance level of the corresponding luminance sample or depends on the average luminance level of the reconstructed luminance sample.

10. The method according to claim 9, wherein the one or more processes include a position-related clipping process depending on a clipping function.

11. The method according to claim 10, wherein the clipping function is defined as y = clip (a, b, x), where x is the sample value before clipping, y is the sample value after clipping, and a and b give the lower and upper limits of y.

12. The method according to claim 10, wherein the clipping function (a, b, x) is defined as (x <= a? a : (x >= b? b : x)).

13. The method according to claim 10, wherein the clipping function (a, b, x) is defined as (x < a? a : (x > b? b : x)).

14. The method according to any one of claims 11 - 13, wherein a and b vary based on the sample position.

15. The method according to claim 14, wherein a is defined as f(x, tc), where x is the input sample value and tc is the deblocking parameter.

16. The method according to claim 15, wherein f(x, tc) is defined as x - (tc * n), where n is a variable.

17. The method according to claim 15, wherein f(x, tc) is defined as x - (tc * n >> 1), where n is a variable.

18. The method according to claim 14, wherein b is defined as g(x, tc), where x is the input sample value and tc is the deblocking parameter.

19. The method according to claim 18, wherein g(x, tc) is defined as x + (tc * m), where m is a variable.

20. The method according to claim 18, wherein g(x, tc) is defined as x + (tc * m >> 1), where m is a variable.

21. The method according to any one of claims 16 - 20, wherein m and / or n vary based on the sample position.

22. The method according to claim 21, wherein larger m and / or n are applied to the samples near the edge compared to the samples far from the edge.

23. The method according to claim 21, wherein the same value of m and / or n is applied to two samples having symmetric positions with respect to the boundary of deblocking.

24. The method according to claim 21, wherein m and / or n are integers.

25. The method according to claim 24, wherein m and / or n depend on at least one of the following: a. Video content, including screen content or natural content; b. A message signaled in at least one of DPS, SPS, VPS, PPS, APS, picture header, slice header, slice group header, maximum coding unit LCU, coding unit CU, LCU row, group of LCUs, TU, PU, block, and video coding unit; c. The position of at least one of CU, PU, TU, block, or video coding unit; d. The block dimension of the current block and / or its adjacent blocks; e. The block shape of the current block and / or its adjacent blocks; f. An indication of the color format, the color format including at least one of 4:2:0, 4:4:4, RGB, or YUV; g. Coding tree structure, including at least one of a binary tree or a single tree; h. At least one of slice type, slice group type, or picture type; i. Color component, including Cb or Cr; j. Temporal layer ID; k. Profile, level, tier of the standard.

26. The method according to claim 24, wherein m and / or n are signaled to the decoder.

27. The method according to claim 9, wherein the one or more parameters include a Qp offset related to a luminance level used in a luminance deblocking process.

28. The method according to claim 27, wherein the Qp offset is derived based on a reconstructed average luminance level.

29. The method according to claim 27, wherein during a chrominance deblocking process, the Qp offset is added to Qp before or after chrominance Qp mapping.

30. A method for processing video, comprising: determining, for a conversion between a first color component of a current block of a video and a bitstream of the first color component of the current block of the video, a deblocking process for the first color component based on corresponding sample values of a second color component of the current block of the video; and, performing the conversion based on the determined deblocking process for the first color component; wherein the deblocking process for the first color component depends on a reconstructed luminance level of corresponding luminance samples or depends on a reconstructed average luminance level of corresponding luminance samples, wherein the first color component is a chrominance component and the second color component is a luminance component.

31. The method according to claim 30, wherein the current block of the video includes one luminance component and two chrominance components, and the first color component is one of the two chrominance components and the second color component is the luminance component.

32. The method according to claim 31, wherein when the video is in YCbCr format, the first color component is a Cb color component or a Cr color component and the second color component is a Y color component.

33. The method according to claim 31, wherein when the video is in RGB format, the first color component is an R color component or a B color component and the second color component is a G color component.

34. The method according to any one of claims 30-33, further comprising: determining, for a conversion between a large block of a video and a bitstream of the large block of the video, a deblocking filter to be performed on a large block boundary of the large block based on deblocking conditions and one or more deblocking filter conditions; and, performing the conversion based on the determined deblocking filter.

35. The method according to claim 34, wherein when the deblocking conditions are satisfied but stronger deblocking filter conditions are not satisfied, a weak deblocking filter is directly performed on the large block boundary.

36. The method according to claim 35, wherein the deblocking conditions for the large block depend on whether samples at the P side or the Q side belong to the large block and / or values of the samples and a first threshold β involved in a deblocking filter decision process.

37. The method according to claim 36, wherein the stronger deblocking filter condition for the large block depends on the value of the sample point, the first threshold β and the second threshold t involved in the deblocking filter decision process C .

38. The method according to claim 34, wherein when the deblocking conditions are satisfied and stronger deblocking filter conditions are not satisfied, but strong deblocking filter conditions are satisfied, a strong deblocking filter is applied on the large block boundary.

39. The method according to claim 38, wherein the deblocking condition of the large block depends on whether the sample points at the P side or the Q side belong to the large block and / or the value of the sample points and a first threshold β involved in the deblocking filter decision process.

40. The method according to claim 39, wherein the stronger deblocking filtering condition for the large block depends on the value of the sample point, the first threshold β and the second threshold t involved in the deblocking filter decision process C .

41. The method according to claim 40, wherein the strong deblocking filter condition of the large block depends on the value of the sample points and the first threshold β involved in the deblocking filter decision process.

42. The method according to any one of claims 1-4, 9-13, 30-33, wherein whether and how to apply the determination step, the application step, and / or the execution step is based on specific conditions.

43. The method according to claim 42, wherein the conditions are a color format of 4:2:0 and / or 4:2:

2.

44. The method according to claim 42, wherein for a 4:4:4 color format, how to apply the deblocking filter to two color chrominance components follows the current design.

45. The method according to claim 42, wherein an indication of the use of the determination step, the application step, and / or the execution step is signaled at at least one of the levels of sequence, picture, slice, tile, brick, video region including SPS, PPS, picture header, and slice header.

46. The method according to claim 42, wherein the use of the determination step, the application step, and / or the execution step is based on at least one of the following: i. Video content, including screen content or natural content; ii. A message signaled in at least one of DPS, SPS, VPS, PPS, APS, picture header, slice header, tile group header, maximum coding unit LCU, coding unit CU, LCU row, group of LCUs, TU, PU block, and video coding unit; iii. The position of at least one of CU, PU, TU, block, or video coding unit; iv. The coding mode of a block containing sample points along an edge; v. The transform matrix applied to a block containing sample points along an edge; vi. The block dimension of the current block and / or its adjacent blocks; vii. The block shape of the current block and / or its adjacent blocks; viii. An indication of the color format, which includes 4:2:0, 4:4:4, RGB, or YUV; ix. The coding tree structure, including a dual tree or a single tree; x. At least one of slice, tile group type, or picture type; xi. Color components, including Cb or Cr; xii. Temporal layer ID; xiii. The profile, level, and tier of the standard.

47. The method according to any one of claims 1-4, 9-13, 30-33, wherein the conversion generates color components or chrominance components of a video from the bitstream.

48. The method according to any one of claims 34-41, wherein the conversion generates the blocks of a video from the bitstream.

49. The method according to any one of claims 1-4, 9-13, 30-33, wherein the conversion generates the bitstream from color components or chrominance components of a video.

50. The method according to any one of claims 34 - 41, wherein the conversion generates the bitstream from the blocks of the video.

51. An apparatus in a video system, comprising a processor and a non - transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method according to any one of claims 1 to 50.

52. A computer program product stored on a non - transitory computer - readable medium, the computer program product comprising program code that, when executed by a processor, causes the processor to implement the method according to any one of claims 1 to 50.

53. A non - transitory computer - readable medium storing program code that, when executed by a processor, causes the processor to implement the method according to any one of claims 1 to 50.

54. A method for storing a bitstream of a video, comprising: For the conversion between the first color component of the current block of a video and the bitstream of the first color component of the current block of the video, one or more deblocking parameters related to the first color component involved in the deblocking filter process are determined based on one or more quantization parameters QP associated with the second color component of the current block of the video; and generating the bitstream based on determined de - blocking parameters; storing the bitstream in a non - transitory computer - readable recording medium; wherein the de - blocking process of the first color component is determined based on the sample values corresponding to the second color component; wherein the de - blocking process for the first color component depends on the reconstructed luminance level of the corresponding luminance samples or depends on the average reconstructed luminance level of the corresponding luminance samples, wherein the first color component is a chrominance component and the second color component is a luminance component.

Images