Method and apparatus for applying deblocking filter to reconstructed video data

Abstract

Systems and methods for applying a deblocking filter to reconstructed video data are disclosed. Sample values in neighboring reconstructed video blocks are modified according to a plurality of passes of the deblocking filter. A filtering pass can correspond to processing or building of all or a subset of samples to be deblocked. The number of processing or building of each sample in a given pass can correspond to a pass index or order.

Description

[0001] This application is a divisional application of Chinese invention patent application No. 201980023322.9, filed on March 25, 2019, entitled "System and method for applying a deblocking filter to reconstruct video data". Technical Field

[0002] This disclosure relates to video coding, and more specifically to techniques for performing deblocking of reconstructed video data. Background Technology

[0003] Digital video capabilities can be integrated into a wide variety of devices, including digital televisions, laptops or desktops, tablets, digital recording devices, digital media players, video game consoles, cellular phones (including so-called smartphones), medical imaging equipment, and more. Digital video can be encoded according to video coding standards. Video coding standards can incorporate video compression techniques. Examples of video coding standards include ISO / IEC MPEG-4 Visual and ITU-T H.264 (also known as ISO / IEC MPEG-4 AVC) and High Efficiency Video Coding (HEVC). HEVC is described in the ITU-T H.265 Recommendation of December 2016, which is incorporated herein by reference and referred to herein as ITU-T H.265. Extensions and improvements to ITU-T H.265 are currently under consideration for developing next-generation video coding standards. For example, the ITU-T Video Coding Experts Group (VCEG) and the ISO / IEC Moving Picture Experts Group (MPEG) (collectively referred to as the Joint Video Study Group (JVET)) are investigating the potential need for standardization of future video coding technologies with compression capabilities significantly exceeding the current HEVC standard. The Joint Exploratory Model 7 (JEM 7), the algorithmic description of Joint Exploratory Test Model 7 (JEM 7), and the ISO / IEC JTC1 / SC29 / WG11 document JVET-G1001 (July 2017, Turin, Italy), which are incorporated herein by reference, describe the coding features of JVET under the Joint Test Model study. This technique is a potential enhanced video coding technique that surpasses the capabilities of ITU-T H.265. It should be noted that the coding features of JEM 7 are implemented in the JEM reference software. As used herein, the term JEM can be used collectively to refer to the algorithms included in JEM 7 and the specific implementations in the JEM reference software.

[0004] Video compression techniques reduce the data requirements for storing and transmitting video data by utilizing the inherent redundancy in video sequences. Video compression techniques can further divide a video sequence into smaller, consecutive segments (i.e., frame groups within a video sequence, frames within a frame group, slices within a frame, coding tree units (e.g., macroblocks) within a slice, coding blocks within a coding tree unit, etc.). Intra-frame predictive coding techniques (e.g., intra-picture (spatial)) and inter-frame predictive coding techniques (i.e., inter-picture (temporal)) can be used to generate the difference between the video data unit to be encoded and a reference unit of the video data. This difference can be referred to as residual data. The residual data can be encoded as quantized transform coefficients. Syntax elements can relate to the residual data and reference coding units (e.g., intra-frame predictive mode indexes, motion vectors, and block vectors). Entropy coding can be applied to the residual data and syntax elements. The entropy-coded residual data and syntax elements can be included in a compatible bitstream. The compatible bitstream and associated metadata can be formatted according to the data structure. Summary of the Invention

[0005] In one example, a method for filtering reconstructed video data includes receiving an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and modifying the sample values ​​in the adjacent reconstructed video blocks according to multiple pass domains of the deblocking filter. Attached Figure Description

[0006] Figure 1 This is a conceptual diagram illustrating an example of a set of images encoded according to a quadtree-binary tree partitioning, wherein the quadtree-binary tree partitioning is based on one or more techniques according to this disclosure.

[0007] Figure 2 This is a conceptual diagram illustrating an example of a video component sampling format according to one or more techniques of this disclosure.

[0008] Figure 3 This is a conceptual diagram illustrating a possible coding structure for video data blocks according to one or more techniques of this disclosure.

[0009] Figure 4A This is a conceptual diagram illustrating an example of encoding video data blocks according to one or more techniques disclosed herein.

[0010] Figure 4B This is a conceptual diagram illustrating an example of encoding video data blocks according to one or more techniques disclosed herein.

[0011] Figure 5A This is a conceptual diagram illustrating a video data block including a deblocking boundary according to one or more techniques according to this disclosure.

[0012] Figure 5B This is a conceptual diagram illustrating a video data block including a deblocking boundary according to one or more techniques according to this disclosure.

[0013] Figure 6 This is an example of a table that can be used to determine unblocking parameters according to one or more techniques of this disclosure.

[0014] Figure 7 This is a block diagram illustrating an example of a system that can be configured to encode and decode video data according to one or more techniques of this disclosure.

[0015] Figure 8 This is a block diagram illustrating an example of a video encoder that can be configured to encode video data according to one or more techniques of this disclosure.

[0016] Figure 9 This is a block diagram illustrating an example of a video decoder that can be configured to decode video data according to one or more techniques of this disclosure. Figure 10 This is a flowchart illustrating an example of execution unblocking according to one or more techniques of this disclosure.

[0017] Figure 11 This is a flowchart illustrating an example of execution unblocking according to one or more techniques of this disclosure.

[0018] Figure 12 This is a flowchart illustrating an example of execution unblocking according to one or more techniques of this disclosure.

[0019] Figure 13 This is an example of a table that can be used to determine unblocking parameters according to one or more techniques of this disclosure.

[0020] Figure 14A This is a conceptual diagram illustrating a video data block including a deblocking boundary according to one or more techniques according to this disclosure.

[0021] Figure 14B This is a conceptual diagram illustrating a video data block including a deblocking boundary according to one or more techniques according to this disclosure. Detailed Implementation

[0022] Generally speaking, this disclosure describes various techniques for encoding video data. Specifically, this disclosure describes techniques for performing deblocking of reconstructed video data. It should be noted that although the techniques disclosed herein are described with respect to ITU-T H.264, ITU-T H.265, and JEM, the techniques disclosed herein are generally applicable to video coding. For example, the coding techniques described herein can be incorporated into video coding systems (including video coding systems based on future video coding standards), including block structures, intra-frame prediction techniques, inter-frame prediction techniques, transform techniques, filtering techniques, and / or entropy coding techniques, different from those included in ITU-T H.265. Therefore, references to ITU-T H.264, ITU-T H.265, and JEM are for descriptive purposes and should not be construed as limiting the scope of the techniques described herein. Furthermore, it should be noted that the inclusion of references herein by way of citation should not be construed as limiting or creating ambiguity with respect to the terminology used herein. For example, if the definition of a term provided in one of the incorporated references differs from that in another incorporated reference and / or as used herein, then the term should be interpreted in a manner that broadly includes each of the corresponding definitions and / or in a manner that includes each particular definition in the alternatives.

[0023] In one example, the device for video encoding includes one or more processors configured to receive an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and to modify the sample values ​​in the adjacent reconstructed video blocks according to multiple domains of a deblocking filter.

[0024] In one example, the non-transitory computer-readable storage medium includes instructions stored thereon that, when executed, cause one or more processors of the device to receive an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and to modify the sample values ​​in the adjacent reconstructed video blocks according to multiple domains of a deblocking filter.

[0025] In one example, the apparatus includes: means for receiving an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and means for modifying the sample values ​​in the adjacent reconstructed video blocks according to a plurality of passages of a deblocking filter.

[0026] Details of one or more examples are set forth in the following figures and description. Other features, objects, and advantages will be apparent from the description, figures, and claims.

[0027] Video content typically comprises a sequence of frames. A series of frames may also be referred to as a group of pictures (GOP). Each video frame or picture may include multiple slices or tiles, where a slice or tile comprises multiple video blocks. As used herein, the term "video block" may generally refer to a region of a picture, or more specifically, to the largest array of sample values ​​that can be predictively encoded, its sub-partitions, and / or corresponding structures. Furthermore, the term "current video block" may refer to a region of a picture that is being encoded or decoded. A video block can be defined as an array of sample values ​​that can be predictively encoded. It should be noted that in some cases, pixel values ​​may be described as sample values ​​comprising the corresponding components of the video data, which may also be referred to as color components (e.g., luminance (Y) and chrominance (Cb and Cr) components or red, green, and blue components). It should be noted that in some cases, the terms "pixel value" and "sample value" are used interchangeably. Video blocks may be ordered within a picture according to a scanning mode (e.g., raster scan). A video encoder may perform predictive coding on video blocks and their sub-partitions. Video blocks and their sub-partitions may be referred to as nodes.

[0028] ITU-T H.264 specifies a macroblock structure comprising 16×16 luma samples. That is, in ITU-T H.264, images are segmented into macroblocks. ITU-T H.265 specifies a similar Coded Tree Unit (CTU) structure, also known as a Maximum Coded Unit (LCU). In ITU-T H.265, images are segmented into CTUs. In ITU-T H.265, for images, the CTU size can be set to include 16×16, 32×32, or 64×64 luma samples. In ITU-T H.265, a CTU consists of a corresponding Coded Tree Block (CTB) for each component of the video data (e.g., luma (Y) and chroma (Cb and Cr)). Furthermore, in ITU-T H.265, CTUs can be partitioned according to a quadtree (QT) partitioning structure, which allows the CTU's CTB to be divided into Coded Blocks (CBs). In other words, in ITU-T H.265, a CTU can be divided into quad-leaf tree nodes. According to ITU-T H.265, a luma CB, along with two corresponding chroma CBs and associated syntax elements, is called a coding unit (CU). In ITU-T H.265, the minimum permissible size of a CB can be signaled. In ITU-T H.265, the minimum permissible size of a luma CB is 8×8 luma samples. In ITU-T H.265, the decision to code a picture region using intra-frame prediction or inter-frame prediction is made at the CU level.

[0029] In ITU-T H.265, a CU (Cubic Component Unit) is associated with a Prediction Unit (PU) structure that has its root at the CU. In ITU-T H.265, the PU structure allows the segmentation of the Luminance CB (Cubic Concentration Block) and Chromaticity CB to generate corresponding reference samples. That is, in ITU-T H.265, the Luminance CB and Chromaticity CB can be segmented into corresponding Luminance and Chromaticity Prediction Blocks (PBs), where each PB comprises a block of sample values ​​to which the same prediction has been applied. In ITU-T H.265, a CB can be divided into one, two, or four PBs. ITU-T H.265 supports PB sizes from 64×64 samples down to 4×4 samples. ITU-T H.265 supports square PBs for intra-frame prediction, where a CB can form a PB, or a CB can be segmented into four square PBs (i.e., intra-frame prediction PB size types include M×M or M / 2×M / 2, where M is the height and width of the square CB). In ITU-T H.265, in addition to square prediction blocks (PBs), rectangular PBs are also supported for inter-frame prediction, where the frame cutoff block (CB) can be halved vertically or horizontally to form the PB (i.e., inter-frame prediction PB types include M×M, M / 2×M / 2, M / 2×M, or M×M / 2). Furthermore, it should be noted that ITU-T H.265 supports four asymmetric PB partitions for inter-frame prediction, where the CB is divided into two PBs at one-quarter of its height (top or bottom) or width (left or right) (i.e., asymmetric partitions include M / 4×M left, M / 4×M right, M×M / 4 top, and M×M / 4 bottom). Intra-frame prediction data (e.g., intra-frame prediction mode syntax elements) or inter-frame prediction data (e.g., motion data syntax elements) corresponding to the PB are used to generate reference and / or prediction sample values ​​for the PB.

[0030] JEM specifies a CTU with a maximum size of 256×256 luminance samples. JEM specifies a Quadtree Plus Binary Tree (QTBT) block structure. In JEM, the QTBT structure allows for further partitioning of quadtree leaf nodes by a binary tree (BT) structure. That is, in JEM, the binary tree structure allows for recursive vertical or horizontal partitioning of quadtree leaf nodes. Figure 1 This illustrates an example where a CTU (e.g., a CTU with a size of 256×256 luminance samples) is partitioned into quadtree leaf nodes, and these quadtree leaf nodes are further partitioned according to a binary tree. That is, in Figure 1 In the diagram, dashed lines indicate additional binary tree partitions within a quadtree. Therefore, the binary tree structure in JEM implements square and rectangular leaf nodes, where each leaf node includes a CB. (See diagram for example.) Figure 1 As shown, the images included in a GOP may include slices, where each slice includes a CTU sequence, and each CTU may be partitioned according to a QTBT structure. Figure 1An example of a QTBT partitioning including a CTU in a slice is shown. Thus, the binary tree structure in JEM implements square and rectangular leaf nodes, where each leaf node includes a CB. In JEM, the CB is used for prediction without any further partitioning. That is, in JEM, a CB can be a block of sample values ​​to which the same prediction is applied. Therefore, a JEM QTBT leaf node can be analogous to a PB in ITU-T H.265.

[0031] The video sampling format (also known as the chroma format) can be defined relative to the number of luminance samples included in the CU. For example, for a 4:2:0 sampling format, the sampling rate of the luminance component is twice the sampling rate of the chroma components in both the horizontal and vertical directions. Therefore, for a CU formatted according to the 4:2:0 format, the width and height of the sample arrays used for the luminance components are twice the width and height of each sample array used for the chroma components. Figure 2 This is a conceptual diagram illustrating an example of a coding unit formatted according to the 4:2:0 sample format. Figure 2 This shows the relative positions of the chromaticity samples with respect to the luminance samples within the CU. As mentioned above, the CU is typically defined based on the number of horizontal and vertical luminance samples. Therefore, as... Figure 2 As shown, the 16×16CU, formatted according to the 4:2:0 sample format, includes 16×16 samples for the luminance component and 8×8 samples for each chrominance component. Furthermore, in Figure 2 The example shown illustrates the relative positions of chroma samples to luma samples for adjacent video blocks of a 16×16 CU. For a CU formatted in 4:2:2 format, the width of the luma component sample array is twice the width of the chroma component sample array, but the height of the luma component sample array is equal to the height of the chroma component sample array. Furthermore, for a CU formatted in 4:4:4 format, the luma component sample array has the same width and height as the chroma component sample array.

[0032] As described above, intra-frame prediction data or inter-frame prediction data is used to generate reference sample values ​​for blocks of sample values. The difference between sample values ​​included in the current PB or another type of picture region structure and the associated reference samples (e.g., those generated using prediction) can be referred to as residual data. Residual data can include a corresponding array of differences corresponding to each component of the video data. Residual data may be in the pixel domain. Transformations such as Discrete Cosine Transform (DCT), Discrete Sine Transform (DST), integer transform, wavelet transform, or conceptually similar transforms can be applied to the array of differences to generate transform coefficients. It should be noted that in ITU-T H.265, a CU is associated with a Transform Unit (TU) structure having its root at the CU level. That is, in ITU-T H.265, to generate transform coefficients, the array of differences can be subdivided (e.g., four 8×8 transforms can be applied to a 16×16 residual array). For each component of the video data, such subdivision of the differences can be referred to as a Transform Block (TB). It should be noted that in ITU-T H.265, a TB is not necessarily aligned with a PB. Figure 3 Examples of alternative PB and TB combinations that can be used to encode a specific CB are shown. Furthermore, it should be noted that in ITU-T H.265, TB can have the following sizes: 4×4, 8×8, 16×16, and 32×32. In JEM, the residual values ​​corresponding to the CB are used to generate transform coefficients without further partitioning. That is, in JEM, the QTBT leaf nodes can be similar to both PB and TB in ITU-T H.265. It should be noted that in JEM, a core transform and a subsequent quadratic transform can be applied (in the video encoder) to generate transform coefficients. For the video decoder, the order of the transforms is reversed. Furthermore, in JEM, whether a quadratic transform is applied to generate transform coefficients may depend on the prediction mode.

[0033] Transform coefficients can be quantized using a quantization process. Quantization approximates the transform coefficients by limiting their amplitude to a specified set of values. Quantization can be used to change the amount of data needed to represent a set of transform coefficients. Quantization can generally be described as being achieved by dividing the transform coefficients by a scaling factor and any associated rounding function (e.g., rounding to the nearest integer). Therefore, inverse quantization (or "dequantization") can include multiplying the bit values ​​of the coefficients by a scaling factor. It should be noted that, as used herein, the term quantization process can in some cases refer to dividing by a scaling factor to generate bit values, or in some cases to multiplying by a scaling factor to recover the transform coefficients. That is, quantization process can refer to quantization in some cases and inverse quantization in others. By performing inverse quantization on the bit values, an inverse transform is performed, and a set of predicted values ​​is added to the resulting residual to reconstruct the current video data block. The sample values ​​of the reconstructed block may differ from the sample values ​​of the current video block that are input into the encoding process. Thus, the encoding can be considered lossy. However, it should be noted that the difference in sample values ​​can be considered acceptable to an observer of the reconstructed video.

[0034] Entropy coding can be applied to the quantized transform coefficients (which may be referred to as bit values) using entropy coding techniques such as Content Adaptive Variable Length Coding (CAVLC), Context Adaptive Binary Arithmetic Coding (CABAC), and Probability Interval Partition Entropy Coding (PIPE). Additionally, syntax elements (such as syntax elements indicating prediction modes) can also be entropy encoded. Entropy-coded quantized transform coefficients and their corresponding entropy-coded syntax elements can form a compatible bitstream that can be used to reproduce video data. As part of the entropy coding process, binarization can be performed on the syntax elements. Binarization is the process of converting syntax values ​​into a sequence of one or more bits. These bits can be referred to as "binary bits". Figures 4A to 4B This is a conceptual diagram illustrating an example of encoding video data blocks. (Example:) Figure 4A As shown, bit-order values ​​are generated by subtracting a set of predicted values ​​from the current block of video data to produce a residual, performing a transformation on the residual, and quantizing the transform coefficients. This process encodes the current block of video data (e.g., the CB corresponding to a video component). Figure 4B As shown, the current video data block is decoded by performing inverse quantization on the bit-order values, performing an inverse transform, and adding the resulting residual to a set of predicted values. It should be noted that... Figures 4A to 4B In the example, the sample values ​​of the reconstructed block differ from the sample values ​​of the current video block being encoded. Thus, the encoding can be considered lossy. However, for a viewer of the reconstructed video, the difference in sample values ​​may be considered acceptable or imperceptible.

[0035] like Figure 4AAs shown, the quantized transform coefficients are encoded into a bitstream. The quantized transform coefficients and syntax elements (e.g., syntax elements indicating the coding structure of video blocks) can be entropy-coded using entropy coding techniques. Examples of entropy coding techniques include Content Adaptive Variable Length Coding (CAVLC), Context Adaptive Binary Arithmetic Coding (CABAC), Probability Interval Partition Entropy Coding (PIPE), etc. The entropy-coded quantized transform coefficients and the corresponding entropy-coded syntax elements can form a compatible bitstream that can be used to reproduce video data at the video decoder. The entropy coding process may include binarizing the syntax elements. Binarization is the process of converting the values ​​of syntax values ​​into a sequence of one or more bits. These bits may be referred to as "binary bits". Binarization is a lossless process and may include one or a combination of the following coding techniques: fixed-length coding, unary coding, truncated unary coding, truncated Rice coding, Golomb coding, k-order exponential Golomb coding, and Golomb-Rice coding. For example, binarization may include representing the integer value 5 of a syntax element as 00000101 using an 8-bit fixed-length binarization technique, or representing the integer value 5 as 11110 using a unary coding binarization technique. As used herein, each of the terms fixed-length coding, unary coding, truncated unary coding, truncated Rice coding, Golomb coding, k-order exponential Golomb coding, and Golomb-Rice coding may refer to a general implementation of these techniques and / or a more specific implementation of these coding techniques. For example, a Golomb-Rice coding implementation may be specifically defined according to a video coding standard (e.g., ITU-T H.265). The entropy coding process also includes encoding bin values ​​using a lossless data compression algorithm. In the CAB AC example, for a particular bin, a context model can be selected from a set of available context models associated with that bin. In some examples, the context model may be selected based on previous bins and / or the values ​​of previous syntax elements. The context model can identify the probability that a particular bin has a specific value. For example, the context model might indicate a probability of 0.7 for encoding a box with a value of 0 and a probability of 0.3 for encoding a box with a value of 1. It should be noted that in some cases, the sum of the probabilities of encoding a box with a value of 0 and encoding a box with a value of 1 may not equal 1. After selecting an available context model, the CABAC entropy encoder can perform arithmetic encoding on the boxes based on the identified context model. The context model can be updated based on the values ​​of the encoded boxes. The context model can also be updated based on associated variables stored with the context, such as window size adaptation and the number of encoded boxes using the context. It should be noted that, according to ITU-TH.265, a CABAC entropy encoder can be implemented such that arithmetic encoding can be used to entropy encode some syntax elements without using an explicitly specified context model; this type of encoding can be called bypass encoding.

[0036] As described above, intra-frame prediction data or inter-frame prediction data can associate regions of an image (e.g., PB or CB) with corresponding reference samples. For intra-frame prediction coding, the intra-frame prediction mode can specify the location of the reference sample within the image. In ITU-T H.265, the possible intra-frame prediction modes defined include a planar (i.e., surface-fitting) prediction mode (predMode: 0), a DC (i.e., flat global average) prediction mode (predMode: 1), and 33 angular prediction modes (predMode: 2-34). In JEM, the possible intra-frame prediction modes defined include a planar prediction mode (predMode: 0), a DC prediction mode (predMode: 1), and 65 angular prediction modes (predMode: 2-66). It should be noted that the planar prediction mode and the DC prediction mode can be referred to as non-directional prediction modes, and the angular prediction mode can be referred to as directional prediction modes. It should be noted that the techniques described herein are generally applicable regardless of the number of possible prediction modes defined.

[0037] For inter-frame predictive coding, motion vectors (MVs) identify reference samples in images other than the image of the video block to be encoded, thereby utilizing temporal redundancy in the video. For example, the current video block can be predicted from one or more reference blocks located in one or more previously encoded frames, and motion vectors can be used to indicate the location of the reference blocks. Motion vectors and associated data can describe, for example, the horizontal component of the motion vector, the vertical component of the motion vector, the resolution of the motion vector (e.g., quarter-pixel accuracy, half-pixel accuracy, one-pixel accuracy, two-pixel accuracy, four-pixel accuracy), the prediction direction, and / or the reference image index value. Furthermore, coding standards such as ITU-T H.265 can support motion vector prediction. Motion vector prediction allows the motion vector to be specified to use the motion vectors of adjacent blocks. Examples of motion vector prediction include Advanced Motion Vector Prediction (AMVP), Temporal Motion Vector Prediction (TMVP), the so-called "merge" mode, and "skip" and "direct" motion inference. In addition, JEM supports Advanced Temporal Motion Vector Prediction (ATMVP), Spatial-Temporal Motion Vector Prediction (STMVP), Pattern Matching Motion Vector Derivation (PMMVD) mode, a special merging mode based on Frame Rate Upconversion (FRUC) technology, and affine transformation motion compensation prediction technology.

[0038] As mentioned above, quantization can be achieved by dividing the transform coefficients by a scaling factor, and can also be used to change the amount of data required to represent a set of transform coefficients. That is, increasing the scaling factor (or quantization level) reduces the amount of data required to represent a set of coefficients. In ITU-T H.265, the quantization level is determined by the quantization parameter QP. In ITU-T H.265, for an 8-bit bit depth, QP can take 52 values ​​from 0 to 51, and a change of 1 in QP typically corresponds to a change of approximately 12% in the quantization scaling factor. It should be noted that, more generally, in ITU-T H.265, the valid range of QP values ​​for the source bit depth is -6*(bit depth - 8) to +51 (inclusive). Therefore, for example, in the case of a 10-bit bit depth, QP can take 64 values ​​from -12 to 51, which can be mapped to values ​​from 0 to 63 during dequantization. In ITU-T H.265, the quantization parameter can be updated for each CU, and the corresponding quantization parameter can be derived for each of the luminance and chrominance components. It should be noted that as the degree of quantization increases (e.g., the transform coefficients are divided by a larger scaling factor value), the amount of distortion can increase (e.g., the reconstructed video data may appear more “blocky” to the user).

[0039] In some cases, chunking artifacts can cause the boundaries of encoded blocks in the reconstructed video data to be visually visible to the user. To reduce chunking artifacts, the reconstructed sample values ​​can be modified to minimize artifacts introduced by the video coding process. Such modifications are generally referred to as filtering. It should be noted that filtering can occur as part of an in-loop filtering process or a post-loop filtering process. For an in-loop filtering process, the sample values ​​obtained from the filtering process can be used to predict video blocks (e.g., stored in a reference frame buffer for subsequent encoding at the video encoder and subsequent decoding at the video decoder). For a post-loop filtering process, the sample values ​​obtained from the filtering process are output only as part of the decoding process (e.g., not used for subsequent encoding). For example, in an in-loop filtering process, the sample values ​​produced by the filtered reconstructed block will be used for subsequent decoding (e.g., stored in a reference buffer) and will be output (e.g., output to a display). In a post-loop filtering process, the unmodified reconstructed block will be used for subsequent decoding, and the sample values ​​produced by the filtered reconstructed block will be output.

[0040] The following arithmetic operators can be used for the formulas used in this article:

[0041] Addition

[0042] - Subtraction

[0043] Multiplication, including matrix multiplication

[0044] / This is an integer division that truncates the result towards zero. For example, it truncates 7 / 4 and -7 / -4 to 1, and -7 / 4 and 7 / -4 to -1. The sum of f(i) takes all integer values ​​from x to y, including y.

[0045] In addition, the following mathematical functions can be used:

[0046]

[0047] Clip1c(x) = Clip3(0, (1 << BitDepthc) - 1, x), where BitDepthc is the bit depth of the chroma pass.

[0048] abs(x) is the absolute value of x.

[0049]

[0050] In addition, the following logical operators can be defined:

[0051] x&&y The Boolean logic "and" of x and y

[0052] The Boolean OR operation between x and y.

[0053] ! Boolean logic "No"

[0054] x? y : z If x is TRUE or not equal to 0, evaluate to y; otherwise, evaluate to z.

[0055] In addition, the following relational operators can be applied:

[0056] > greater than

[0057] ≥ greater than or equal to

[0058] <less than

[0059] ≤ less than or equal to

[0060] == equals

[0061] ! = not equal to

[0062] In addition, the following bitwise operators can be applied:

[0063] x >> y is an arithmetic right shift of the binary representation of y in two's complement. This function is defined only for non-negative integer values ​​of y. The bits shifted into the most significant bit (MSB) by the right shift have the same MSB value as x before the shift operation.

[0064] x << y is an arithmetic left shift of the binary representation of y in two's complement. This function is defined only for non-negative integer values ​​of y. The bits shifted to the least significant bit (LSB) due to the left shift have a value equal to 0.

[0065] Deblocking (or unblocking), deblocking filtering, performing deblocking, or applying a deblocking filter refers to the process of smoothing the boundary between a video block and adjacent reconstructed video blocks (i.e., making the boundary less noticeable to the observer). Smoothing the boundary between adjacent reconstructed video blocks can include modifying sample values ​​in rows or columns included near the boundary. ITU-T H.265 provides scenarios for applying deblocking filters to reconstructed sample values ​​as part of a loop filtering process. ITU-T H.265 includes two types of deblocking filters that can be used to modify luminance samples: strong filters, which modify sample values ​​in three rows or columns adjacent to the boundary; and weak filters, which modify sample values ​​in rows or columns immediately adjacent to the boundary and conditionally modify sample values ​​in the second row or column starting from the boundary. Additionally, ITU-T H.265 includes a type of filter that can be used to modify chroma samples, namely, the ordinary filter.

[0066] Figures 5A to 5B The diagram illustrates sample values ​​included in video blocks P and Q with boundaries. As used herein, video blocks P and Q are used to refer to adjacent video blocks having block boundaries on which unblocking can be applied. The modification of sample values ​​can be based on defined filters, where pi and qi represent the corresponding sample values ​​in the columns of the vertical boundaries and the sample values ​​in the rows of the horizontal boundaries, and pi′ and qi′ represent the modified sample values. Defined filters define the samples to be modified (or filtered) and the filters used to determine how to modify the samples. For example, as... Figure 5A As shown, in one example, the sample values ​​(shown as filtered samples) in each of the first three columns adjacent to the unblock boundary can be modified based on the sample values ​​(shown as support samples) included in each of the first four columns adjacent to the unblock boundary.

[0067] As mentioned above, ITU-T H.265 includes two types of filters that can be used to modify luminance samples: strong filters and weak filters. Simplified definitions of the formulas for strong and weak filters used to modify luminance sample values ​​are provided below. These definitions are simplified because they do not include the clipping operation provided in ITU-T H.265 (i.e., in ITU-T H.265, the filtered value is clipped based on the value tC, as described below); however, the complete definition is provided in Section 8.7.2.5.7 of ITU-T H.265.

[0068] strong filter

[0069] p0'=(p2+2*p1+2*p0+2*q0+q1+4) / 8

[0070] p1' = (p2 + p1 + p0 + q0 + 2) / 4

[0071] p2'=(2*p3+3*p2+p1+p0+q0+4) / 8

[0072] q0'=(p1+2*p0+2*q0+2*q1+q2+4) / 8

[0073] q1' = (p0 + q0 + q1 + q2 + 2) / 4

[0074] q2'=(p0+q0+q1+3*q2+2*q3+4) / 8

[0075] Weak filter

[0076] Δ=(9*(q0-p0)-3*(q1-p1)+8) / 16

[0077] p0'=p0+Δ

[0078] q0'=q0-Δ

[0079] As described below, p1 and q1 are conditionally modified as follows:

[0080] Δp=((p2+p0+1) / 2-p1+Δ) / 2

[0081] Δq=((q2+p0+l) / 2-q1-Δ) / 2

[0082] p1'=p1+Δp

[0083] q1'=q1+Δq

[0084] In addition, ITU-T H.265 includes a type of filter that can be used to modify chroma samples: the ordinary filter. A simplified definition of the ordinary filter formula for modifying chroma sample values ​​is provided below.

[0085] Ordinary filter

[0086] Δ=((q0-p0)*4+p1-q1+4) / 8

[0087] p0'=p0+Δ

[0088] q0'=q0-Δ

[0089] Unblocking can be performed based on unblocking granularity. ITU-T H.265 provides an 8×8 unblocking granularity. That is, in ITU-T H.265, for a region of an image, each edge located on an 8×8 grid is evaluated to determine whether a boundary exists. Furthermore, in ITU-T H.265, the boundary strength (Bs) of each boundary is determined. In ITU-T H.265, Bs is determined to be one of 0, 1, or 2, as follows:

[0090] If P and Q are two adjacent coded blocks, then the filter strength Bs is specified as:

[0091] If one of the blocks (P or Q) has an intra-prediction mode, then Bs = 2;

[0092] Additionally, if P and Q belong to different TBs, then P or Q has at least one non-zero transformation coefficient, and Bs = 1.

[0093] Additionally, if the reference images for P and Q are not the same, then Bs = 1;

[0094] Additionally, if the difference between the x-axis motion vector components or the y-axis motion vector components of P and Q is equal to or greater than an integer sample, then Bs = 1;

[0095] Additionally, Bs = 0.

[0096] In ITU-T H.265, based on the method for classifying video blocks P and Q (which may be referred to as QP), P QP is encoded by CB of QPQ) to determine variable t. C 'and β'. Figure 6 Provides a method for determining t C The table for ' and β'. In ITU-T H.265, index Q is determined as follows:

[0097] Regarding brightness:

[0098] For β':

[0099] Q = Clip3(0, 51, qP) L +(slice_beta_offset_div2<<1))

[0100] For t C '

[0101] Q = Clip3(0, 53, qP) L +2*(bS-1)+(slice_tc_offset_div2<<1)),

[0102] in,

[0103] qPL =(QP Q +QP P +1) / 2;

[0104] slice_beta_offset_div2 is applied to include sample q. 0,0 The offset value of the video data slice; and

[0105] slice_tc_offset_div2 is applied to include sample q. 0,0 Offset values ​​of video data slices

[0106] ITU-TH.265, the variables β and Q are derived as follows:

[0107] β=β′*(1<<(BitDepth y -8))

[0108] tc = tc′ * (1 << (BitDepth) y -8))

[0109] BitDepth y Specifies the bit depth of the luminance sample.

[0110] ITU-TH.265 defines the variable d, which is determined based on luminance sample values, as follows:

[0111] dp0 = abs(p 2，0 -2*p 1，0 +p 0，0 )

[0112] dp3 = abs(p 2，3 -2*p 1，3 +P 0，3 )

[0113] dq0=abs(q 2，0 -2*q 1，0 +q 0，0 )

[0114] dq3=abs(q 2，3 -2*q 1，3 +q 0，3 )

[0115] dpq0=dp0+dq0

[0116] dpq3=dp3+dq3

[0117] dp = dp0 + dp3

[0118] dq = dq0 + dq3

[0119] d = dpq0 + dpq3

[0120] Furthermore, in ITU-T H.265, the variable dpq is set to a value based on the d and β values. Finally, in ITU-T H.265, each of Bs, tC, β, and d is used to determine which type of filter (e.g., strong or weak filter) is applied. Additionally, in ITU-T H.265, for the chroma component, a standard filter is applied only when Bs equals 2. That is, in ITU-T H.265, if either block P or Q is generated using an intra-prediction mode, deblocking occurs only for the chroma component.

[0121] It should be noted that it can often be useful to describe the unblocking filter based on a set of filter parameters. For example, for a set of sample values ​​{a...b} included in rows or columns, the corresponding unblocking sample value y[n] can be specified based on the following formula:

[0122]

[0123] in,

[0124] The filter length is determined to be abs(a-b+1);

[0125] coeff[m] provides the filter tap values ​​(also known as filter coefficients). For example, for {a...b} = {0...4}, a set of tap values ​​could be {1, 2, 3, 2, 1};

[0126] x[n+m] provides the input sample values ​​corresponding to the support samples. It should be noted that the support size can be greater than or equal to the filter length.

[0127] Furthermore, in ITU-T H.265, the deblocking filter can be applied differently to CTU boundaries that coincide with slice and tile boundaries compared to CTU boundaries that do not coincide with slice and tile boundaries. Specifically, ITU-T H.265 specifies the flag slice_loop_filter_across_slices_enabled_flag, which exists in the slice header, to enable / disable the deblocking filter across CTU boundaries that coincide with the top and left slice boundaries. ITU-T H.265 provides the following definition for slice_loop_filter_across_slices_enabled_flag:

[0128] `slice_loop_filter_across_slices_enabled_flag` equal to 1 specifies that in-loop filtering operations can be performed across the left and top boundaries of the current slice. `slice_loop_filter_across_slices_enabled_flag` equal to 0 specifies that in-loop operations are not performed across the left and top boundaries of the current slice. In-loop filtering operations include unblocking filtering and sample adaptive offset filtering. When `slice_loop_filter_across_slices_enabled_flag` is not present, it is inferred to be equal to `pps_loop_filter_across_slices_enabled_flag`.

[0129] The pps_loop_filter_across_slices_enabled_flag exists in the Picture Parameter Set (PPS), and ITU-T H.265 provides the following definition for pps_loop_filter_across_slices_enabled_flag:

[0130] `pps_loop_filter_across_slices_enabled_flag` equal to 1 specifies that in-loop filtering can be performed across the left and top boundaries of slices in the reference PPS. `pps_loop_filter_across_slices_enabled_flag` equal to 0 specifies that in-loop filtering cannot be performed across the left and top boundaries of slices in the reference PPS. In-loop filtering operations include unblocking filtering and sample adaptive offset filtering.

[0131] Note - You can enable cyclic filtering across tile boundaries while disabling it, and vice versa.

[0132] Similarly, the flag `loop_filter_across_tiles_enabled_flag` in the PPS enables / disables the deblocking filter across CTU boundaries coinciding with tile boundaries. ITU-T H.265 provides the following definition for `loop_filter_across_tiles_enabled_flag`: `loop_filter_across_tiles_enabled_flag` equal to 1 indicates that in-loop filtering can be performed across tile boundaries in the picture within the reference PPS. `loop_filter_across_tiles_enabled_flag` equal to 0 indicates that in-loop filtering is not performed across tile boundaries in the picture within the reference PPS. In-loop filtering operations include deblocking filtering and sample adaptive offset filtering. When it does not exist, the inferred value of `loop_filter_across_tiles_enabled_flag` is equal to 1.

[0133] As described above, for unblocking, the index Q is determined based on slice_beta_offset_div2 and slice_tc_offset_div2. In ITU-T H.265, the values ​​of slice_beta_offset_div2 and slice_tc_offset_div2 can be included in the slice fragment header and have the following definitions:

[0134] `slice_beta_offset_div2` and `slice_tc_offset_div2` specify the β and t values ​​of the current slice. C The unblocking parameter offset (divided by 2). The values ​​of slice_beta_offset_div2 and slice_tc_offset_div2 should both be in the range of -6 to 6 (inclusive). When not present, the values ​​of slice_beta_offset_div2 and slice_tc_offset_div2 are inferred to be equal to topps_beta_offset_div2 and pps_tc_offset_div2, respectively.

[0135] pps_beta_offset_div2 and pps_tc_offset_div2 exist in PPS, and ITU-TH.265 provides the following definitions for pps_beta_offset_div2 and pps_tc_offset_div2:

[0136] pps_beta_offset_div2 and pps_tc_offset_div2 specify the β and t values ​​applied to the slice of the reference PPS.C The default unblocking parameter offset (divided by 2), unless overridden by a unblocking parameter offset present in the slice header of the slice referencing the PPS. The values ​​of pps_beta_offset_div2 and pps_tc_offset_div2 should both be in the range of -6 to 6 (inclusive). If they do not exist, the values ​​of pps_beta_offset_div2 and pps_tc_offset_div2 are assumed to be equal to 0.

[0137] As mentioned above, ITU-T H.265 provides an 8×8 unblocking granularity. In JEM, unblocking is performed according to a grid specified by the variable minCUWidth of the horizontal boundary or the variable minCUHeight of the vertical boundary, where the default values ​​for minCUWidth and minCUHeight are 4. The value of d is also determined in JEM, and its calculation is the same as in ITU-T H.265. Based on the aforementioned value of d, it is determined whether to perform unblocking on the boundary. That is, if d < β, the unblocking filter is used for the current boundary; otherwise, unblocking is not performed on that boundary. Furthermore, the decision to use a strong filter or a weak filter in JEM is the same as in ITU-T H.265. Finally, in the JEM reference software, the brightness filter coefficients of the strong unblocking filter are the same as those used in ITU-T H.265. Unblocking performed in both ITU-T H.265 and JEM may not be ideal. Specifically, deblocking, as performed in ITU-T H.265 and JEM, fails to take into account the various coding parameters and attributes of the reconstructed video data during the deblocking process.

[0138] Figure 7 This is a block diagram illustrating an example of a system that can be configured to encode (e.g., encode and / or decode) video data according to one or more techniques of this disclosure. System 100 represents an example of a system that can encapsulate video data according to one or more techniques of this disclosure. Figure 7 As shown, system 100 includes source device 102, communication medium 110, and target device 120. Figure 7In the example shown, source device 102 may include any device configured to encode video data and transmit the encoded video data to communication medium 110. Target device 120 may include any device configured to receive and decode the encoded video data via communication medium 110. Source device 102 and / or target device 120 may include computing devices equipped for wired and / or wireless communication, and may include, for example, set-top boxes, digital video recorders, televisions, desktop computers, laptops or tablets, game consoles, medical imaging equipment, and mobile devices (including, for example, smartphones, cellular phones, and personal gaming devices).

[0139] Communication medium 110 may include any combination of wireless and wired communication media and / or storage devices. Communication medium 110 may include coaxial cable, fiber optic cable, twisted-pair cable, wireless transmitters and receivers, routers, switches, repeaters, base stations, or any other device that can be used to facilitate communication between various devices and sites. Communication medium 110 may include one or more networks. For example, communication medium 110 may include a network configured to allow access to the World Wide Web, such as the Internet. The network may operate according to a combination of one or more telecommunications protocols. Telecommunication protocols may include proprietary aspects and / or may include standardized telecommunications protocols. Examples of standardized telecommunications protocols include the Digital Video Broadcasting (DVB) standard, the Advanced Television Systems Committee (ATSC) standard, the Integrated Services Digital Broadcasting (ISDB) standard, the Cable Data Services Interface Specification (DOCSIS) standard, the Global System for Mobile Communications (GSM) standard, the Code Division Multiple Access (CDMA) standard, the 3rd Generation Partnership Project (3GPP) standard, the European Telecommunications Standards Institute (ETSI) standard, the Internet Protocol (IP) standard, the Wireless Application Protocol (WAP) standard, and the Institute of Electrical and Electronics Engineers (IEEE) standard.

[0140] Storage devices can include any type of device or storage medium capable of storing data. Storage media can include tangible or non-transitory computer-readable media. Computer-readable media can include optical discs, flash memory, magnetic storage, or any other suitable digital storage medium. In some examples, a memory device or a portion thereof may be described as non-volatile memory, and in other examples, a portion of a memory device may be described as volatile memory. Examples of volatile memory can include random access memory (RAM), dynamic random access memory (DRAM), and static random access memory (SRAM). Examples of non-volatile memory can include magnetic hard disks, optical discs, floppy disks, flash memory, or electrically programmable memory (EPROM) or electrically erasable and programmable (EEPROM) memory. Storage devices can include memory cards (e.g., secure digital (SD) memory cards), internal / external hard disk drives, and / or internal / external solid-state drives. Data can be stored on the storage device according to defined file formats.

[0141] Refer again Figure 7 Source device 102 includes a video source 104, a video encoder 106, a data encapsulator 107, and an interface 108. Video source 104 may include any device configured to capture and / or store video data. For example, video source 104 may include a camera and a storage device operatively coupled thereto. Video encoder 106 may include any device configured to receive video data and generate a compatible bitstream representing the video data. A compatible bitstream can refer to a bitstream from which a video decoder can receive and reproduce video data. Aspects of a compatible bitstream may be defined according to a video coding standard. When generating a compatible bitstream, video encoder 106 may compress the video data. Compression may be lossy (perceptible to an observer) or lossless.

[0142] Figure 8 This is a block diagram illustrating an example of a video encoder 200 capable of implementing the techniques described herein for encoding video data. It should be noted that although the exemplary video encoder 200 is shown as having different functional blocks, such illustrations are intended for descriptive purposes and do not limit the video encoder 200 and / or its sub-components to a particular hardware or software architecture. The functionality of the video encoder 200 can be implemented using any combination of hardware, firmware, and / or software implementations. In one example, the video encoder 200 may be configured to encode video data according to the techniques described herein. The video encoder 200 may perform intra-frame predictive coding and inter-frame predictive coding of picture regions, and thus may be referred to as a hybrid video encoder. Figure 8In the example shown, video encoder 200 receives a source video block. In some examples, the source video block may include picture regions that have been partitioned according to the coding structure. For example, source video data may include macroblocks, CTUs, CBs, their sub-partitions, and / or additional equivalent coding units. In some examples, the video encoder may be configured to perform additional subdivision of the source video block. It should be noted that the techniques described herein are generally applicable to video coding, regardless of how the source video data is partitioned before and / or during coding. Figure 9 In the example shown, the video encoder 200 includes a summer 202, a transform coefficient generator 204, a coefficient quantization unit 206, an inverse quantization / transform processing unit 208, a summer 210, an intra-frame prediction processing unit 212, an inter-frame prediction processing unit 214, a filter unit 216, and an entropy coding unit 218. Figure 8 As shown, the video encoder 200 receives source video blocks and outputs a bitstream.

[0143] exist Figure 8 In the example shown, video encoder 200 can generate residual data by subtracting a predicted video block from a source video block. Summer 202 represents the component configured to perform this subtraction operation. In one example, the subtracted video block appears in the pixel domain. Transform coefficient generator 204 applies a transform, such as Discrete Cosine Transform (DCT), Discrete Sine Transform (DST), or a conceptually similar transform, to its residual block or sub-partition (e.g., four 8×8 transforms can be applied to a 16×16 residual value array) to generate a set of residual transform coefficients. Transform coefficient generator 204 can be configured to perform any and all combinations of transforms included in the discrete trigonometric transform family. Transform coefficient generator 204 can output the transform coefficients to coefficient quantization unit 206.

[0144] Coefficient quantization unit 206 can be configured to perform quantization of the transform coefficients. As described above, the degree of quantization can be modified by adjusting the quantization scaling factor, which can be determined by the quantization parameters. Coefficient quantization unit 206 can be further configured to determine quantization values ​​and output QP data, which can be used by the video decoder to reconstruct quantization parameters for inverse quantization during video decoding. For example, the QP data of the signal transmission may include QPΔ values. In ITU-TH.265, the degree of quantization applied to the transform coefficient set can depend on: slice-level parameters, parameters inherited from previous coding units, and / or optionally, CU-level Δ values ​​of the signal transmission.

[0145] like Figure 8As shown, the quantized transform coefficients are output to the inverse quantization / transform processing unit 208. The inverse quantization / transform processing unit 208 can be configured to apply inverse quantization and / or inverse transform to generate reconstructed residual data. For example... Figure 8 As shown, at summer 210, the reconstructed residual data can be added to the predicted video block. This allows for the reconstruction of the encoded video block, and the resulting reconstructed video block can be used to evaluate the coding quality for a given prediction, transform type, and / or quantization bit order. The video encoder 200 can be configured to perform multiple coding rounds (e.g., performing coding while changing one or more coding parameters). The rate-distortion or other system parameters of the bitstream can be optimized based on the evaluation of the reconstructed video block. Furthermore, the reconstructed video block can be stored and used as a reference for predicting subsequent blocks.

[0146] As described above, intra-frame prediction can be used to encode video blocks. The intra-frame prediction processing unit 212 can be configured to select an intra-frame prediction mode for the video block to be encoded. The intra-frame prediction processing unit 212 can be configured to evaluate frames and / or regions thereof and determine the intra-frame prediction mode to be used for encoding the current block. Figure 8 As shown, the intra-frame prediction processing unit 212 outputs intra-frame prediction data (e.g., syntax elements) to the filter unit 216 and the entropy coding unit 218.

[0147] Inter-frame prediction processing unit 214 can be configured to perform inter-frame prediction coding for the current video block. Inter-frame prediction processing unit 214 can be configured to receive a source video block and calculate motion vectors such as the PU of the video block. The motion vectors can indicate the displacement of the PU of the video block within the current video frame relative to the predicted block within a reference frame. Inter-frame prediction coding can use one or more reference pictures. Furthermore, motion prediction can be unidirectional prediction (using one motion vector) or bidirectional prediction (using two motion vectors). Inter-frame prediction processing unit 214 can be configured to select a prediction block by calculating pixel differences determined by, for example, the sum of absolute differences (SAD), the sum of squared differences (SSD), or other difference metrics. Motion vectors and related data can describe, for example, the horizontal component of the motion vector, the vertical component of the motion vector, the resolution of the motion vector (e.g., quarter-pixel precision), the prediction direction, and / or the reference picture index value. Furthermore, coding standards such as ITU-T H.265 can support motion vector prediction. Motion vector prediction allows the motion vector to be specified to use the motion vectors of adjacent blocks. Examples of motion vector prediction include Advanced Motion Vector Prediction (AMVP), Temporal Motion Vector Prediction (TMVP), the so-called "merge" mode, and "skip" and "direct" motion inference. Inter-frame prediction processing unit 214 can be configured to perform motion vector prediction according to one or more of the techniques described above. Inter-frame prediction processing unit 214 can be configured to generate prediction blocks using motion prediction data. For example, inter-frame prediction processing unit 214 can locate prediction video blocks within a frame buffer ( Figure 8 (Not shown in the image). Note that the inter-frame prediction processing unit 214 can be further configured to apply one or more interpolation filters to the reconstructed residual block to compute sub-integer pixel values ​​for motion estimation. The inter-frame prediction processing unit 214 can output the motion prediction data of the computed motion vectors to the filter unit 216 and the entropy coding unit 218.

[0148] As mentioned above, deblocking refers to the process of smoothing and reconstructing the boundaries of video blocks. For example... Figure 8 As shown, filter unit 216 receives reconstructed video blocks and coding parameters (e.g., intra-frame prediction data, inter-frame prediction data, and QP data) and outputs modified reconstructed video data. Filter unit 216 can be configured to perform deblocking and / or sample adaptive offset (SAO) filtering. SAO filtering is a nonlinear amplitude mapping that can be used to improve the reconstruction by adding an offset to the reconstructed video data. It should be noted that, as Figure 8As shown, the intra-frame prediction processing unit 212 and the inter-frame prediction processing unit 214 can receive modified reconstructed video blocks via the filter unit 216. That is, in some cases, deblocking can occur within a loop, i.e., the predicted video blocks stored in the reference buffer can be filtered. In other cases, deblocking can occur after a loop, i.e., for example, after reconstructing the video data and before outputting it to the display. The techniques described herein are applicable to in-loop deblocking, post-loop deblocking, and / or combinations of both.

[0149] As mentioned above, deblocking performed as in ITU-T H.265 and JEM may be less than ideal. In one example, according to the techniques described herein, filter unit 216 may be configured to select different filter lines based on one or more of the following (in some cases, the number of samples to be deblocked on each side of the boundary may be different): block size on each side (one or both sides) of the boundary, boundary strength, prediction mode used by the blocks on each side of the boundary, prediction mode of the sample being deblocked (e.g., intra-frame, inter-frame, skip) (e.g., using a weak filter on the boundary near the reference sample), QP value of the sample being deblocked, block size corresponding to the sample being deblocked, block size corresponding to the sample being used for deblocking, motion vector of the block on each side of the boundary being deblocked, motion vector of the sample being deblocked, and / or motion vector of the sample being used for deblocking.

[0150] Samples on each side of the block boundary (perpendicular to the boundary edge) can be represented as:

[0151] ...p8 p7 p6 p5 p4 p3 p2 p1 p0 |q0 q1 q2 q3 q4 q5 q6 q7 q8...

[0152] in,

[0153] | indicates the edge of the block boundary.

[0154] Sample px (where x is a positive integer starting from 0) represents the P side of the boundary. Sample qy (where y is a positive integer starting from 0) represents the Q side of the boundary.

[0155] In one example, the P side represents the samples outside the current CU, and the Q side represents the samples inside the current CU.

[0156] In one example, the P side represents the samples inside the current CU, and the Q side represents the samples outside the current CU.

[0157] In one example, the P side represents samples outside the current block, and the Q side represents samples inside the current block.

[0158] In one example, the P side represents samples inside the current block, and the Q side represents samples outside the current block.

[0159] refer to Figure 5A When the block is unblocked at the vertical edge, sample p y＞x and q y＞x This corresponds to the line R[x].

[0160] refer to Figure 5B When unblocking horizontal edges, sample P y＞x and q y＞x Corresponding to line R[y].

[0161] An example of a wider (i.e., more samples to unblock) and stronger filter on the P-side boundary (called a WSOOP P-side filter) is:

[0162] p6′=(7*p7+2*p6+p5+p4+p3+p2+p1+p0+q0+8)>>4

[0163] p5′=(6*p7+p6+2*p5+p4+p3+p2+p1+p0+q0+q1+8)>>4

[0164] p4′=(5*p7+p6+p5+2*p4+p3+p2+p1+p0+q0+q1+q2+8)>>4

[0165] p3′=(4*p7+p6+p5+p4+2*p3+p2+p1+p0+q0+q1+q2+q3+8)>>4

[0166] p2′=(3*p7+p6+p5+p4+p3+2*p2+p1+p0+q0+q1+q2+q3+q4+8)>>4

[0167] p1′=(2*p7+p6+p5+p4+p3+p2+2*p1+p0+q0+q1+q2+q3+q4+q5+8)>>4

[0168] p0′=(p7+p6+p5+p4+p3+p2+p1+2*p0+q0+q1+q2+q3+q4+q5+q5+8)>>4

[0169] Where, p x ′ indicates that in the case of p x Sample values ​​after unblocking at the location

[0170] An example of a wider (i.e., more samples to unblock) and stronger filter on the Q-side of the boundary (called the WS00Q Q-side filter) is:

[0171] q6′=(7*q7+2*q6+q5+q4+q3+q2+q1+q0+p0+8)>>4

[0172] q5′=(6*q7+q6+2*q5+q4+q3+q2+q1+q0+p0+p1+8)>>4

[0173] q4′=(5*q7+q6+q5+2*q4+q3+q2+q1+q0+p0+p1+p2+8)>>4

[0174] q3′=(4*q7+q6+q5+q4+2*q3+q2+q1+q0+p0+p1+p2+p3+8)>>4

[0175] q2′=(3*q7+q6+q5+q4+q3+2*q2+q1+0+p0+p1+p2+p3+p4+8)>>4

[0176] q1′=(2*q7+q6+q5+q4+q3+q2+2*q l +q0+p0+p1+p2+p3+p4+p5+8)>>4

[0177] q0′=(q7+q6+q5+q4+q3+q2+q1+2*q0+p0+p1+p2+p3+p4+p5+p6+8)>>4

[0178] Where, q x ' indicates that in the case of q x Sample values ​​after unblocking at the location

[0179] An example of a narrow (i.e., fewer samples to unblock) and strong filter on the P-side of the boundary (called the HEVC_P P-side filter) is:

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

[0181] p1′=(p2+p1+p0+q0+2)>>2

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

[0183] Where, p x ′ indicates that in the case of p x Sample values ​​after unblocking at the location

[0184] An example of a narrow (i.e., fewer samples to unblock) and strong filter on the Q-side of the boundary (called a HEVC_Q Q-side filter) is:

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

[0186] p1′=(p2+p1+p0+q0+4)>>3

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

[0188] Where, q x ' indicates that in the case of q x Sample values ​​after unblocking at the location

[0189] An example of a narrow (fewer samples to unblock), strong filter on the P-side boundary (called an NS00P P-side filter) is:

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

[0191] p1′=(p2+p1+p0+q0+4)>>3

[0192] p2′=.(p4+2*p3+3*p2+p1+p0+4)>>3

[0193] Where, p x ′ indicates that in the case of p x Sample values ​​after unblocking at the location

[0194] An example of a narrow (fewer samples to unblock), strong filter on the Q-side of the boundary (called an NS00Q Q-side filter) is:

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

[0196] q1′=(q2+q1+q0+p0+4)>>3

[0197] q2′=(q4+2*q3+3*q2+q1+q0+4)>>3

[0198] Where, q x ' indicates that in the case of q x Sample values ​​after unblocking at the location

[0199] An example of a narrow (fewer samples to unblock), strong filter on the P-side boundary (called an NS00P P-side filter) is:

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

[0201] p1′=(p2+p1+p0+q0+2)>>2

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

[0203] An example of a narrow (fewer samples to unblock), strong filter on the Q-side of the boundary (called an NS00Q Q-side filter) is:

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

[0205] q1′=(q2+q1+q0+p0+2)>>2

[0206] q2′=(q4+2*q3+3*q2+q1+q0+4)>>3

[0207] An example of a narrow (fewer samples to unblock), strong filter on the P-side boundary (called an NS00P P-side filter) is:

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

[0209] p1′=(p2+p1+p0+q0+2)>>2

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

[0211] An example of a narrow (fewer samples to unblock), strong filter on the Q-side of the boundary (called an NS00Q Q-side filter) is:

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

[0213] q1′=(q2+q1+q0+p0+2)>>2

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

[0215] An example of a narrow (fewer samples to unblock) and weak filter on the P-side boundary (called an NW00P P-side filter) is:

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

[0217] p0′=Clip1 C (p0+Δ)

[0218] Where px′ represents the sample value after unblocking at the position corresponding to px.

[0219] An example of a narrow (fewer samples to unblock) and weak filter on the Q-side of the boundary (called an NW00Q Q-side filter) is:

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

[0221] q0′=Clip1 C (q0-A)

[0222] Where qx' represents the sample value after unblocking at the position corresponding to qx.

[0223] An example of a filter on the P-side of the boundary (called an FOP P-side filter) is:

[0224] p0'=(136*p8+120*q8+128)>>8

[0225] p1'=(151*p7+105*q9+128)>>8

[0226] p2'=(166*p6+90*q 10 +128)>>8

[0227] p3'=(181*p5+75*q 11 +128)>>8

[0228] p4'=(196*p4+60*q 12 +128)>>8

[0229] p5'=(211*p3+45*q 13 +128)>>8

[0230] p6'=(226*p2+30*q 14 +128)>>8

[0231] p7'=(241*p1+15*q 15 +128)>>8

[0232] An example of a filter on the Q-side of the boundary (called an F0Q Q-side filter) is:

[0233] q0'=(120*p9+136*q7+128)>>8

[0234] q I '=(105*p 10+151*q6+128)>>8

[0235] q2'=(90*p 11 +166*q5+128)>>8

[0236] q3'=(75*p 12 +181*q4+128)>>8

[0237] q4'=(60*p 13 +196*q3+128)>>8

[0238] q5'=(45*p 14 +211*q2+128)>>8

[0239] q6'=(30*p 15 +226*q1+128)>>8

[0240] q7'=(15*p 16 +241*q0+128)>>8

[0241] An example of a filter on the P-side of the boundary (called an F1P P-side filter) is:

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

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

[0244] p2′=(p3+p2+p1+p0+2)>>2

[0245] p3′=(p4+p3+p2+p1+2)>>2

[0246] An example of a filter on the Q-side of the boundary (called an F1Q Q-side filter) is:

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

[0248] q1′=(2*q2+4*q1+q0+p0+4)>>3

[0249] q2′=(q3+q2+q1+q0+2)>>2

[0250] q3′=(q4+q3+q2+q1+2)>>2

[0251] In one example, the distance of the sample being deblocked from the boundary can be inversely proportional to the distance between the supporting sample assigned the largest tap value and the sample being deblocked. Furthermore, the distance of the second largest tap value from the sample being deblocked can be proportional to the distance of the sample from the boundary. The filters F2P and F2Q described below provide exemplary implementations of such filtering. An example of a filter on the P-side of the boundary (referred to as an F2P P-side filter) is:

[0252] p0'=(136*p8+2*p0+120*q8+256)>>9

[0253] p1'=(151*p7+4*p1+105*q9+256)>>9

[0254] p2'=(166*p6+8*p2+90`*q 10 +256)>>9

[0255] p3'=(181*p5+16*p3+75*q 11 +256)>>9

[0256] p4'=(196*p4+32*p4+60*q 12 +256)>>9

[0257] p5'=(211*p3+64*p5+45*q 13 +256)>>9

[0258] p6'=(226*p2+128*p6+30*q 14 +256)>>9

[0259] p7'=(241*p1+256*p7+15*q 15 +256)>>9

[0260] An example of a filter on the Q-side of the boundary (called an F2Q Q-side filter) is:

[0261] q0'=(120*p9+2*q0+136*q7+256)>>9

[0262] q1'=(105*p 10 +4*q1+151*q6+256)>>9

[0263] q2'=(90*p 11 +8*q² + 166*q⁵ + 256) >> 9

[0264] q3'=(75*p 12 +16*q³+181*q⁴+256)>>9

[0265] q4'=(60*p 13 +32*q4+196*q3+256)>>9

[0266] q5'=(45*p 14 +64*q5+211*q2+256)>>9

[0267] q6'=(30*p 15 +128*q6+226*q1+256)>>9

[0268] q7'=(15*p 16 +256*q7+241*q0+256)>>9

[0269] An example of a filter on the P-side of the boundary (called an F4P P-side filter) is:

[0270] p6'=(7*p7+2*p6+p5+p4+p3+p2+p1+p0+q0+8)>>4

[0271] p5'=(6*p7+p6+2*P5+p4+p3+p2+p1+p0+q0+q1+8)>>4

[0272] p4'=(5*p7+p6+p5+2*p4+p3+p2+p1+p0+q0+q1+q2+8)>>4

[0273] p3'==(4*p7+p6+p5+p4+2*p3+p2+p1+p0+q0+q1+q2+q3+8)>>4

[0274] p2'=(3*p7+p6+p5+p4+p3+2*p2p1+p0+q0+q1+q2+q3+q4+8)>>4

[0275] p1'=(2*p7+p6+p5+p4+p3+p2+2*p1+p0+q0+q1+q2+q3+q4+q5+8)>>4

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

[0277] An example of a filter on the Q-side of the boundary (called an F4Q Q-side filter) is:

[0278] q6'=(7*q7+2*q6+q5+q4+q3+q2+q1+q0+p0+8)>>4

[0279] q5'=(6*q7+q6+2*q5+q4+q3+q2+q1+q0+p0+p1+8)>>4

[0280] q4'=(5*q7+q6+q5+2*q4+q3+q2+q1+q0+p0+p1+p2+8)>>4

[0281] q3'=(4*q7+q6+q5+q4+2*q3+q2+q1+q0+p0+p1+p2+p3+8)>>4

[0282] q2'=(3*q7+q6+q5+q4+q3+2*q2+q1+q0+p0+p1+p2+p3+p4+8)>>4

[0283] q1'=(2*q7+q6+q5+q4+q3+q2+2*q1+q0+p0+p1+p2+p3+p4+p5+8)>>4

[0284] q0'=(q7+q6+q5+q4+q3+q2+q1+2*q0+p0+p1+p2+p3+p4+p5+p6+8)>>4

[0285] In one example, according to the techniques described in this paper, gradient computation can be used to select filter parameters and the number of samples to unblock on one (or both) side of the block boundary. The gradient can be computed using samples in the line R[x].

[0286] In one example, samples in line R[x] can be used to compute multiple gradients and used to select filter parameters and the number of samples to unblock on one (or both) side of the block boundary. In another example, samples in line R[x] can be used to compute multiple gradients and operations such as averaging, maximum gradient, and minimum gradient can be used to select filter parameters and the number of samples to unblock on one (or both) side of the block boundary.

[0287] In one example, the function call xCalDQp(R[x]) calculates the gradient as follows:

[0288] abs(p2-2*p1+p0)

[0289] In one example, the function call xCalDQq(R[x]) calculates the gradient as follows:

[0290] abs(q2-2*q1+q0)

[0291] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0292] Max (Max (

[0293] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0294] Max (Max (

[0295] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0296] (abs(p2-2*p1+p0)+abs(p3-2*p2+p1)+abs(p5-2*p4+p3)+abs(p7-2*p6+p5)+4)>>2

[0297] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0298] (abs(q2-2*q1+q0)+abs(q3-2*q2+q1)+abs(q5-2*q4+q3)+abs(q7-2*q6+q5)+4)>>>2

[0299] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0300] (abs(p2-2*p1+p0)+abs(p3-2*p2+p1)+abs(p5-2*p4+p3)+abs(p7-2*p6+p5)+2)>>2

[0301] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0302] (abs(q2-2*q1+q0)+abs(q3-2*q2+q1)+abs(q5-2*q4+q3)+abs(q7-2*q6+q5)+2)>>2

[0303] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0304] (abs(p2-2*p1+p0)+abs(p3-2*p2+p1)+abs(p4-2*p3+p2)+abs(p5-2*p4+p3)+4)>>2

[0305] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0306] (abs(q2-2*q1+q0)+abs(q3-2*q2+q1)+abs(q4-2*q3+q2)+abs(q5-2*q4+q3)+4)>>2

[0307] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0308] (abs(p2-2*p1+p0)+abs(p3-2*p2+p1)+abs(p4-2*p3+p2)+abs(p5-2*p4+p3)+2)>>2

[0309] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0310] (abs(q2-2*q1+q0)+abs(q3-2*q2+q1)+abs(q4-2*q3+q2)+abs(q5-2*q4+q3)+2)>>2

[0311] In one example, the function call xCalDQpLargeBlock(R[x]) calculates the gradient as follows:

[0312] (abs(p2-2*p1+p0)+abs(p5-2*p4+p3)+1)>>1

[0313] In one example, the function call xCalDQqLargeBlock(R[x]) calculates the gradient as follows:

[0314] (abs(q2-2*q1+q0)+abs(q5-2*q4+q3)+1)>>1

[0315] In one example, a subset of the second differences computed at p1, p2, ..., p6 can be used to compute the second difference at pn, where abs(p n-1-2*p n +P n+1 xCalDQpLargeBlock(R[x]).

[0316] Similarly, a subset of the second difference computed at q1, q2, ..., q6 can be used to compute xCalDQqLargeBlock(R[x]). In one example, the rounding offset in the function calls xCalDQpLargeBlock(R[x]) and xCalDQqLargeBlock(R[x]) can be discarded.

[0317] In one example, the function call xUseStrongFilteringLargeBlock(R[x0, d, bSidePisLargeBlk, bSideQisLargeBlk)) calculates the Boolean variables as follows, where examples of bSidePisLargeBlk and bSideQisLargeBlk are provided below:

[0318] ((abs((bSidePisLargeBlk?p7:p4)-p0)+abs((bSideQisLargeBlk?q7:q4)-q0)<(β>>3))&&(d<(β>>2))&&(abs(q0-p0)<((t C *5+1)>>1)))? TRUE:FALSE,where β and t C The threshold value is used.

[0319] In one example, the function call xUseStrongFilteringLargeBlock(R[x], d, bSidePisLargeBlk, bSideQisLargeBlk) calculates the Boolean variables as follows:

[0320] sp3 = Abs(p3 - p0)

[0321] if(bSidePisLargeblk)

[0322] {

[0323] sp3=max(sp3,ma(Abs(p7-p3),Abs(p7-p0))

[0324] }

[0325] sq3 = Abs(q0 - q3)

[0326] if(bSideQi Largeblk) (

[0328] sq3=max(sq3,max(Abs(q7-q3),Abs(q7-q0)))

[0329] }

[0330] xUscStrongFileringLargeBlock: sp3+sq3<(β>>3)%&(d<(β>>2))&&(abs(q0-p0)

[0331] <((t) C *5+1)>>1)))? TRUE: FALSE.

[0332] In one example, the function call xUseStrongFilteringLargeBlock(R[x], d, bSidePisLargeBlk, bSideQisLargeBlk) calculates the Boolean variables as follows:

[0333] sp3 = Abs(p3 - p0)

[0334] if(bSidePisLargeblk)

[0335] {

[0336] sp3-(sp3+Abs(p7-p3)+1)>>1

[0337] }

[0338] sq3 = Abs(q0 - q3)

[0339] if(bSideQisLargeblk) (

[0341] sq3=(sq3+Abs(q7-q3))+1)>>1

[0342] }

[0343] xUseStrongFilteringLargeBlock: sp3+sq3<(β>>3)&&(d<(β>>2))&&(abs(q0-p0)

[0344] <((t) c *5+1)>>1)))? TRUE:FALSE

[0345] In one example, the function call xUseStrongFilteringLargeBlock(R[x], d, bSidePisLargeBlk, bSideQisLargeBlk) calculates the Boolean variables as follows:

[0346] sp3 = Ab(p3 - p0)

[0347] if(bSidePisLargeblk)

[0348] {

[0349] sp3=(sp3+Abs(p7-p3))+1)>>1

[0350] }

[0351] sq3 = Abs(q0 - q3)

[0352] if(bSideQisLargeblk)

[0353] {

[0354] sq3=(sq3+Abs(q7-q0)+1)>>1

[0355] }

[0356] xUseStrongFilteringLargeBl ck:sp3+sq3<(β>>3)&&(d<(β>>2))&&(abs(q0-p0)

[0357] <((t) C *5+1)>>1)))? TRUE:FALSE

[0358] In one example, the rounding offset in the function call xUseStrongFilteringLargeBlock can be discarded.

[0359] In one example, the condition for selecting the number of samples to unpack on one (or both) side of the boundary corresponds to the size (of the current and / or adjacent blocks) perpendicular to the block boundary exceeding a threshold. In some cases, when a subset of the transform coefficients for a block is set to zero based on the block size, the threshold used in the comparison can be based on the properties of the subset of zero coefficients. For example, when the transform coefficients of coefficients with column positions greater than or equal to 32 and row positions greater than or equal to 32 are set to zero (where row and column indices start from 0), the size perpendicular to the block boundary is compared to a threshold of 32.

[0360] In one example, a signal indicating whether all transform coefficients are zero for a sample block can be received in the bitstream. For example, such a signal can be received for each color component, for a set of color components, for some spatial partitions of the samples, and for some spatial-temporal partitions of the samples. In HEVC, for each color component, the coded block flags (CBF) - cbf_luma, cbf_cb, cbf_cr are signaled (in the absence of explicit signals, either explicitly or implicitly using inference rules); additionally, a flag indicating whether any color component in the transform tree contains non-zero transform coefficients is also signaled (either explicitly or implicitly), referred to as the residual quadtree root CBF - rqt_root_cbf.

[0361] In one example, the number of samples to be deblocked on one (or both) side of a boundary can be based on the type of edge being deblocked (e.g., vertical block edge, horizontal block edge), channel type (e.g., luminance, chrominance), whether all transform coefficients are zero for sample blocks on one (or both) side of the boundary, whether sample blocks on one (or both) side of the boundary utilize coding patterns such as Local Illumination Compensation (LIC) that may be based on a linear model for illumination variations, whether sample blocks on one (or both) side of the boundary utilize cross-component prediction (which may be based on a linear model), whether sample blocks on one (or both) side of the boundary utilize predictions determined for blocks smaller than the transform, and whether sample blocks on one (or both) side of the boundary utilize techniques where large blocks (e.g., CUs) are divided into sub-blocks (e.g., sub-CUs) and motion information is derived for these sub-blocks.

[0362] In one example, according to the technique described herein, when the size of the current block perpendicular to the block boundary is greater than or equal to a threshold (e.g., 32), a larger number of samples (e.g., 7) are decoded on each side of the block boundary, and when the size of the current block perpendicular to the block boundary is less than the threshold (e.g., 32), a smaller number of samples (e.g., 3) are decoded on each side of the block boundary. For example, if ((the width of the current block is >= 32 and the edge type is vertical) or (the height of the current block is >= 32 and the edge type is horizontal)), a larger number of samples are decoded on each side of the block boundary.

[0363] In one example, according to the technique described herein, when the size of a block perpendicular to the block boundary is greater than or equal to a threshold (e.g., 32), a larger number of samples (e.g., 7) are decoded on the side of the block boundary, and when the size of a block perpendicular to the block boundary is less than the threshold (e.g., 32), a smaller number of samples (e.g., 3) are decoded on the side of the block boundary. For example, if ((a block width >= 32 and the edge type is vertical) or (a block height >= 32 and the edge type is horizontal)), a larger number of samples of that block are decoded at the block boundary. Here, if the block size to the left of the vertical boundary edge is 4 (rows) × 64 (columns) and the block size to the right is 4 (rows) × 16 (columns), a larger number of samples can be decoded on both the left and right sides.

[0364] In one example, according to the techniques described herein, filter unit 216 may be configured to select filter parameters for deblocking based on one or more of the following (including, for example, the number of coefficients): the distance of the sample being deblocked from the boundary (in terms of the number of samples), the block size on each side of the boundary, the boundary strength, the prediction mode used by the blocks on each side of the boundary, the prediction mode of the sample being deblocked (e.g., using a weaker filter for the boundary closer to the reference sample), the QP of the sample being deblocked (e.g., using a stronger filter for a larger QP), the block size corresponding to the sample being deblocked (e.g., using a stronger filter for a larger block size), the block size corresponding to the sample being used for deblocking, the motion vector for the blocks on each side of the boundary being deblocked (e.g., if the MV difference is greater than a threshold, no deblocking is performed because samples on different sides of the boundary may belong to different objects) and / or the motion vector for the sample being deblocked; the motion vector for the sample being used for deblocking. It should be noted that the block size corresponding to a sample may include the block size of the CU to which the sample belongs, the block size of the TU to which the sample belongs, or the block size of the PU to which the sample belongs.

[0365] In one example, according to the techniques described herein, filter unit 216 may be configured to select filter parameters for deblocking based on one or more of the following (including, for example, the number of coefficients): the type of edge being deblocked (e.g., vertical block edge, horizontal block edge), channel type (e.g., luminance, chrominance), whether all transform coefficients are zero for sample blocks on one (or both) side of the boundary, whether sample blocks on one (or both) side of the boundary utilize coding patterns such as Local Illumination Compensation (LIC) that may be based on a linear model for illumination variations, whether sample blocks on one (or both) side of the boundary utilize cross component prediction (which may be based on a linear model), whether sample blocks on one (or both) side of the boundary utilize predictions determined for blocks smaller than the transform, and whether sample blocks on one (or both) side of the boundary utilize techniques in which large blocks (e.g., CUs) are divided into sub-blocks (e.g., sub-CUs) and motion information is derived for these sub-blocks.

[0366] In one example, according to the techniques described herein, filter unit 216 may be configured to select filter parameters for deblocking based on one or more of the following (including, for example, the number of coefficients): the type of edge being deblocked (e.g., vertical block edge, horizontal block edge), channel type (e.g., luminance, chrominance), whether all transform coefficients are zero for sample blocks on one (or both) side of the boundary, whether sample blocks on one (or both) side of the boundary utilize coding patterns such as Local Illumination Compensation (LIC) that may be based on a linear model for illumination variations, whether sample blocks on one (or both) side of the boundary utilize cross component prediction (which may be based on a linear model), whether sample blocks on one (or both) side of the boundary utilize predictions determined for blocks smaller than the transform, and whether sample blocks on one (or both) side of the boundary utilize techniques in which large blocks (e.g., CUs) are divided into sub-blocks (e.g., sub-CUs) and motion information is derived for these sub-blocks.

[0367] In one example, selecting filter parameters may include choosing a wider and stronger filter.

[0368] In one example, according to the techniques described herein, filter unit 216 may be configured to select a set of deblocking filter parameters (e.g., wider and stronger filtering) for both sides when the size of the current block perpendicular to the block boundary is greater than or equal to a threshold (e.g., 32). For example, a wider and stronger filtering is selected for each side of the block boundary if ((the width of the current block is >= 32 and the edge type is vertical) or (the height of the current block is >= 32 and the edge type is horizontal)).

[0369] In one example, according to the techniques described herein, filter unit 216 can be configured to independently select filter parameters for each side of the block boundary based on the size of the block perpendicular to the block boundary. For example, when the size of the block on one side perpendicular to the block boundary is greater than or equal to a threshold (e.g., 32), a set of deblocking filter parameters (e.g., wider and stronger filtering) can be selected for that side. For example, if ((a block width >= 32 and the edge type is vertical) or (a block height >= 32 and the edge type is horizontal)), then a wider and stronger filtering is selected for the side of the block boundary corresponding to that block.

[0370] In one example, according to the techniques described herein, a block sub-CU boundary can be solved based on whether all transform coefficients of a block (e.g., a CU) on one (or both) side of the boundary are zero. For example, a block sub-CU boundary is solved when all transform coefficients of the CU are zero.

[0371] In one example, according to the techniques described herein, a block-to-sub-block boundary can be solved based on whether all the transform coefficients of the block on one (or both) side of the boundary are zero. For example, a block-to-sub-block boundary is solved when all the transform coefficients of the block are zero.

[0372] In one example, according to the techniques described herein, a sub-CU boundary can be solved based on whether all transform coefficients of a block (e.g., a CU) on one (or both) side of the boundary are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold). For example, a sub-CU boundary is solved when all transform coefficients of the CU are zero and QP is greater than a threshold.

[0373] In one example, according to the techniques described herein, a block sub-block boundary can be solved based on whether all transform coefficients of the block on one (or both) side of the boundary are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold). For example, a block sub-block boundary is solved when all transform coefficients of the block are zero and QP is greater than a threshold.

[0374] In one example, according to the techniques described herein, a block boundary can be unblocked when Local Illumination Compensation (LIC) is applied to a block on one (or both) side of the boundary and all transformation coefficients of that block are zero.

[0375] In one example, according to the technique described herein, when Local Illumination Compensation (LIC) is applied to a block and all transformation coefficients of that block are zero, all four boundaries of the block (i.e., left, right, top, and bottom) of the block can be unblocked.

[0376] In one example, according to the techniques described herein, a block boundary can be deblocked when Local Illumination Compensation (LIC) is applied to a block on one (or both) side of the boundary and all transform coefficients of that block are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold).

[0377] In one example, according to the techniques described herein, when Local Illumination Compensation (LIC) is applied to a block and all transform coefficients of that block are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold), all four boundaries of the block (i.e., left, right, top, and bottom) can be deblocked.

[0378] In one example, according to the technique described in this paper, a block boundary can be unblocked when cross-component prediction is used for a block on one (or both) side of the boundary and all transform coefficients of that block are zero.

[0379] In one example, according to the techniques described herein, a block boundary can be deblocked when cross-component prediction is used for a block on one (or both) side of the boundary and all transform coefficients of that block are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold).

[0380] In one example, according to the techniques described herein, filter unit 216 can be configured to perform unblocking based on multiple filter passes. In one example, a filter pass may correspond to the processing / construction of all / a subset of the samples to be unblocked. The number of processing / constructions per sample in a given pass may correspond to the pass index / order. A subset of the samples to be unblocked may correspond to the pass index / order. In one example, each pass may correspond to all processing / construction of the samples to be completely unblocked once. In one example of this, unblocked samples (and non-unblocked samples) from previous iterations can be used to construct the unblocked samples for the current iteration. In one example of this, unblocked samples (and non-unblocked samples) from both previous and current iterations can be used to construct the unblocked samples. In this case, the order used to construct the unblocked samples can be specified. In one example, the number of iterations may be determined based on one or more of the following: slice type; block size; skip flags of the current CU and its neighboring CUs; ​​prediction modes (intra-frame / inter-frame) of the current CU and its neighboring CUs; ​​the location of the sample to be deblocked; whether d < β; and / or the strong or weak filter determination conditions provided in JEM above; the distance of the sample being deblocked from the boundary (in terms of the number of samples); the block size on each side of the boundary; the boundary strength; the prediction mode used by the blocks on each side of the boundary; the prediction mode of the sample being deblocked; the QP of the sample being deblocked; the block size corresponding to the sample being deblocked; the block size corresponding to the sample being used for deblocking; the motion vector of the block being deblocked on each side of the boundary; the motion vector for the sample being deblocked; and / or the motion vector for the sample being used for deblocking. In one example, the number of iterations may determine one or more filter parameters.

[0381] In one example, an N-domain solution block with predetermined solution block support can be represented as:

[0382] For iterIdx = 0 to (N-1)

[0383] For samples from pos = posM to posN / / being unblocked

[0384] temp[pos] = f_pos(sample value at the local area iterldx in the unblocking support)

[0385] For pos = posM to posN

[0386] Update sampleValue[pos] using temp[pos]

[0387] Where f_pos() is a linear transformation of the following form:

[0388]

[0389] Where coeff_oos[] is an array of values ​​depending on the position pos of the sample being unblocked. It should be noted that unblocking can be used in previous iterations to generate each sampleVa1ue[] that is being used. Furthermore, unblocking support does not change from one iteration to the next.

[0390] Performing iterative analysis provides:

[0391] For iterldx 0, the samples used are non-block samples, therefore for each pos:

[0392] temp[pos] = f_pos(sample value at node 0 in the unblocking support)

[0393] For iterldx 1,

[0394] temp[pos] = f_pos(sample value at domain 1 in the unblocking support)

[0395] Since f_pos() is a linear transformation and the unblocking support remains unchanged, the above can be rewritten as:

[0396] For iterldx 1,

[0397] temp[pos] = g_pos(sample value at node 0 in the unblocking support)

[0398] g_pos() is a linear transformation similar to f_pos(), which depends on the position pos, but with different coefficient values.

[0399] This simplification can be performed recursively for each iteration, making the filtering operation depend only on the original sample values ​​at iteration 0, resulting in an equivalent one-pass filter. Due to the finite precision used in some cases, the final coefficient values ​​may be approximate, leading to an approximate one-pass representation of the multi-pass filtering operation.

[0400] In one example, according to the techniques described herein, filter unit 216 can be configured to extend filter lines and corresponding filter coefficients. In one example, the sample lines to be filtered can be extended to eight on one side. In one example, for lines 0 and 1, the filter coefficients can be {1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1} / 16; for lines 2 and 3, the filter coefficients can be {1, 1, 1, 1, 1, 1, 1, 1} / 8; and for the other lines, the filter coefficients can be {1, 2, 2, 2, 1} / 8, where line 0 represents the sample line closest to the boundary.

[0401] It should be noted that in JEM, reconstructed samples are always used to filter samples during the unblocking process. In one example, according to the techniques described herein, filter unit 216 can be configured to use modified sample values ​​generated by unblocking to filter other sample values. In one example, the modified sample values ​​can be used as input when filtering other sample values. In one example, the filtering order can be specified. In one example, the filtering order can be to perform unblocking from the line furthest from the boundary to the line closest to the boundary.

[0402] As described above, deblocking samples are typically clipped to fall within a range of values. This range of values ​​can be based on the original sample values ​​and other parameters received in the bitstream. In one example, the range of values ​​is [original sample value - t_c, original sample value + t_c]. In one example, according to the techniques described herein, filter unit 216 can be configured to adjust the clipping function based on one or more of the following: sample values ​​from the last round or more rounds of multi-pass domain deblocking; QP value; slice type; current prediction mode (intra / inter-frame); current skip flag value; intra-frame prediction mode of the sample to be deblocked; motion vector of the sample to be deblocked; sample location (e.g., different samples may use different clipping functions); CU location (e.g., different CUs may use different clipping functions); and / or any other conditions described above.

[0403] In one example, according to the techniques described herein, filter unit 216 may be configured to perform the filtering techniques described herein based on block size. For example, one or more of the filtering techniques described herein may be applied to a boundary where the block size around the boundary is greater than a threshold. For example, determining whether to perform a filtering technique may be as follows: (1) examining each set of 4×4 samples on each side of the boundary (i.e., since the minimum CU size is 4×4 luminance samples); (2) if any set of 4×4 samples belongs to a CU with a size greater than a threshold (e.g., 64), then the filtering technique will be performed on the current boundary. In one example, according to the techniques described herein, filter unit 216 may be configured to perform the filtering techniques described herein based on one or more of the following: slice type; whether the block shape is rectangular; where the block shape is square; skip flags of the current CU and its neighboring CUs; ​​prediction mode (intra-frame / inter-frame) of the current CU and its neighboring CUs; ​​sample location of the block to be decoded.

[0404] In one example, according to the techniques described herein, filter unit 216 can be configured to perform a wider and stronger luminance filter as follows:

[0405] First, determine whether to utilize large blocks on the P side as follows:

[0406] bSidePisLargeBlk = ((edge ​​type is vertical and p0 belongs to a block with width >= 32 (e.g., CU)) || (edge ​​type is horizontal and p0 belongs to a block with height >= 32 (e.g., CU))) ? TRUE: FALSE

[0407] Next, determine whether to utilize large blocks on the Q side as follows:

[0408] bSideQisLargeBlk = ((edge ​​type is vertical and q0 belongs to a block with width >= 32 (e.g., CU)) || (edge ​​type is horizontal and q0 belongs to a block with height >= 32 (e.g., CU))) ? TRUE: FALSE Next, the following variables are derived:

[0409] d0P=bSidePisLargeBlk? XCalDQpLargeBlock(R[0]):XCalDQp(R[0])

[0410] d1P-bSidePisLargeBlk? XCalDQpLargeBlock(R[3]):XCalDQp(R[3])

[0411] d0Q=bSideQisLargeBlk? XCalDQqLargeBlock(R[0])XCalDQq(R[0])

[0412] dlQ=bSideQLargeBlk? XCalDQqLargeBlock(R[3]):XCalDQq(R[3])

[0413] d0L=d0P+d0Q

[0414] d3L=d1P+dlQ

[0415] dL=d0L+d3L

[0416] Next, evaluate Condition1 and Condition2 as follows:

[0417] Condition 1=(dL<β)? TRUE:FALSE

[0418] Condition2=(xUseStrongFilteringLargeBlock(R[0],d0L,bSidePisLargeBlk,bSideQisLargeBlk)&&xUseStrongFilteringLargeBlock(R[3],d3L,bSidePisLargeBlk,bSideQisLargeBlk))? TRUE:FALSE

[0419] When Condition1, Condition2, and bSidePisLargeBlk are TRUE, a wider and stronger filter is applied to the P side of the boundary (e.g., WS00P).

[0420] When Condition 1, Condition 2, and bSideQisLargeBlk are TRUE, a wider and stronger filter is applied to the Q side of the boundary (e.g., WS00Q).

[0421] In one example, Condition2 can be modified as follows:

[0422] Condition2 = (When a block on either side of the boundary is compensated for by local lighting and the block's CBF is 0)? TRUE: ((xUseStrongFilteringLargeBlock(R[0], d0L, bSidePisLargeBlk, bSideQisLargeBlk)&&xUseStrongFilteringLargeBlock(R[3], d3L, bSidePisLargeBlk, bSideQisLargeBlk))? TRUE: FALSE)

[0423] In one example, according to the techniques described herein, filter unit 216 can be configured to perform chroma filtering as follows:

[0424] When (edge ​​type is vertical and p0 belongs to CU with width >= 32) || (edge ​​type is horizontal and p0 belongs to CU with height >= 32) && (edge ​​type is vertical and q0 belongs to CU with width >= 32) || (edge ​​type is horizontal and q0 belongs to CU with height >= 32), a narrow strong filter (e.g., NS00P and NS00Q) can be used; otherwise, a narrow weak filter (e.g., NW00P and NW00Q) can be used.

[0425] In one example, according to the techniques described herein, filter unit 216 can be configured to perform chroma filtering as follows:

[0426] When (p0 belongs to a CU with width >= 32 and p0 belongs to a CU with height >= 32)||(q0 belongs to a CU with width >= 32 and q0 belongs to a CU with height >= 32), a narrow strong filter (e.g., NS00P and NS00Q) can be used; otherwise, a narrow weak filter (e.g., NW00P and NW00Q) can be used.

[0427] In one example, according to the techniques described herein, filter unit 216 can be configured to... Figure 10 The exemplary flowchart shown performs deblocking filtering. In one example, filter unit 216 can be configured to perform deblocking filtering according to... Figure 10 The flowchart shown in the image demonstrates the performance of deblocking filtering on the brightness samples. Figure 10 Examples are shown of one of the following types of unblocking that can be applied to the current block (e.g., one of the P-blocks or Q-blocks): a wide, strong filter, a strong filter, a weak filter, or no filtering. In one example, applying a wide, strong filter may include applying the WS00P and WS00Q filters described above. In one example, applying a strong filter may include applying the HEVC P and HEVC Q filters described above. In one example, applying a weak filter may include applying a weak filter in HEVC, as described above. Figure 10 As shown, a wider and stronger filter is applied at 408, no filter is applied at 412, a strong filter is applied at 416, and a weak filter is applied at 418 based on the following conditions: whether the large block condition at 402 is true, whether the large block gradient condition at 404 is true, whether the large block strong filter condition at 406 is true, whether the gradient condition at 410 is true, and whether the strong filter condition at 414 is true.

[0428] In one example, a large block condition could include whether the following is true: If((EDGE_VER&&(cur_block_width>=32||adjacent_block_width>=32))||(EDGE_HOR&&(cur_block_height>=32||adjacent_block_height>=32)))

[0429] in

[0430] EDGE_VER is a vertical boundary type.

[0431] EDGE_HOR is a horizontal boundary type.

[0432] cur_block_width is, for example, the current block width in the luminance sample.

[0433] cur_block_height is, for example, the current block height in the luminance sample.

[0434] adjacent_block_width is, for example, the width of the adjacent block in the luminance sample, and

[0435] adjacent_block_height is, for example, the height of the adjacent block in the brightness sample.

[0436] In one example, a large gradient condition may include whether condition 1 above is true. In another example, a large strong filter condition may include whether one of the exemplary Conditions above is true.

[0437] In one example, the gradient condition may include whether d < β, where d is determined as follows:

[0438] d0P=XCalDQp(R[0])

[0439] d1P=XCalDQp(R[3])

[0440] d0Q=XCalDQq(R[0])

[0441] dlQ=XCalDQq(R[3])

[0442] d0 = d0P + d0Q;

[0443] d3 = d1P + dlQ;

[0444] d = d0 + d3;

[0445] In one example, a strong filter condition could include whether the following is true: (xUseStrongFilteringLargeBlock(R[0], d0, false, false) && xUseStrongFilteringLargeBlock(R[3], d3, false, false))? TRUE: FALSE

[0446] In one example, according to the techniques described herein, filter unit 216 can be configured to... Figure 11 The exemplary flowchart shown performs deblocking filtering. In one example, filter unit 216 can be configured to perform deblocking filtering according to... Figure 11 The flowchart shown in the figure demonstrates the deblocking filtering process for the chroma samples. Figure 11 Examples are shown of one of the following types of unblocking methods that can be applied to the current block (e.g., P-block or Q-block): a wide, strong filter or a weak filter. In one example, applying a wide, strong filter may include applying the NS00P and NS00Q filters described above. In one example, applying a weak filter may include applying the NW00P and NW00Q filters described above. Figure 11 As shown, a wider and stronger filter is applied at 504, and a weaker filter is applied at 506 based on whether the large block condition at 502 is true.

[0447] In one example, a large block condition could include whether the following is true: If((EDGE_VER&&(cur_block_width>=32||adjacent_block_width>=32))||(EDGE_HOR&&(cur_block_height>=32||adjacent_block_height>=32)))

[0448] in

[0449] EDGE_VER is the vertical boundary type, EDGE_HOR is the horizontal boundary type, cur_block_width is, for example, the current block width in the chroma sample, cur_block_height is, for example, the current block height in the chroma sample, adjacent_block_width is, for example, the width of the adjacent block in the chroma sample, and adjacent_block_height is, for example, the height of the adjacent block in the chroma sample.

[0450] In one example, filter unit 216 may be configured to perform deblocking filtering on the chroma samples of a P-block or Q-block based on the following set of conditions: if ((EDGE_VER&&(cur_Q_block_width>=TH_w))||(EDGE_HOR&&(cur_Q_block_height>=TH_h)) is TRUE, then NS00Q is applied to the Q samples. Otherwise, a weak filter (e.g., NW00Q Q-side filter) is applied to the Q samples.

[0451] If ((EDGE_VER&&(cur_P_block_width>=TH_w))||(EDGE_HOR&&(cur_P_block_height>=TH_h)) is TRUE, then NSOOP is applied to the P samples. Otherwise, a weak filter (e.g., NW0OP P-side filter) is applied to the P samples.

[0452] in

[0453] EDGE_VER is a vertical boundary type.

[0454] EDGE_HOR is a horizontal boundary type.

[0455] cur_Q_block_width is, for example, the width of the current Q-block in the chroma sample.

[0456] cur_Q_block_height is, for example, the height of the current Q-block in the chroma sample.

[0457] cur_P_block_width is, for example, the width of the current P block in the chroma sample.

[0458] cur_P_block_height is, for example, the height of the current P block in the chroma sample.

[0459] TH_w is the width threshold (e.g., 32 samples), and

[0460] TH_h is the height threshold (e.g., 32 samples).

[0461] It should be noted that the threshold (e.g., TH_w and / or TH_h) may include predefined values ​​(e.g., 16 or 32) in some examples, may be signaled in the parameter set in some examples, may be signaled in the slice header in some examples, and may be the CTU size in the current part of the video in some examples.

[0462] refer to Figure 11In one example, a large block condition can be replaced by a luma filter condition. That is, for example, if a strong filter is applied to the luma block, a wide, stronger filter can be applied to the juxtaposed chroma block at 504, otherwise a weak filter can be applied to the juxtaposed chroma block at 506.

[0463] In one example, according to the techniques described herein, filter unit 216 can be configured to... Figure 12 The exemplary flowchart shown performs deblocking filtering. In one example, filter unit 216 can be configured to perform deblocking filtering according to... Figure 12 The flowchart shown in the figure demonstrates the deblocking filtering process for the chroma samples. Figure 12 Examples are shown of one of the following types of unblocking methods that can be applied to the current block (e.g., a P-block or a Q-block): a wide, strong filter or a weak filter. In one example, applying a wide, strong filter may include applying the NS00P and NSOOQ filters described above. In one example, applying a weak filter may include applying the NW00P and NW00Q filters described above. Figure 12 As shown, a wider and stronger filter is applied at 608, and a weaker filter is applied at 606 based on the following conditions: whether the large block condition at 602 is true and whether the large block strong filter condition at 604 is true.

[0464] In one example, a large block condition could include whether the following is true: If((EDGE_VER&&(cur_block_width>=TH_w&&adjacent_block_width>=TH_w))||(EDGE_HOR&&(cur_block_height>=TH_h||adjacent_block_height>=TH_h)))

[0465] in

[0466] EDGE_VER is a vertical boundary type.

[0467] EDGE_HOR is a horizontal boundary type.

[0468] cur_block_width is, for example, the current block width in the chroma sample.

[0469] cur_block_height is, for example, the current block height in the chroma sample.

[0470] adjacent_block_width is, for example, the width of the adjacent block in the chroma sample, and

[0471] adjacent_block_height is, for example, the height of adjacent blocks in a chroma sample.

[0472] TH_w is the width threshold (e.g., 32 samples), and

[0473] TH_h is the height threshold (e.g., 32 samples).

[0474] It should be noted that the threshold (e.g., TH_w and / or TH_h) may include predefined values ​​(e.g., 16 or 32) in some examples, may be signaled in the parameter set in some examples, may be signaled in the slice header in some examples, and may be the CTU size in the current part of the video in some examples. In one example, the threshold is greater than 4.

[0475] In one example, a broader strong filter condition may include whether both the first and second conditions are true. That is, the strong filter condition can be true when both the first and second conditions are true. In one example, the first condition can be true when d < β, where d is determined as follows:

[0476] dp0 = xCalcDP(Rc[0]);

[0477] dq0=xCalcDQ(R c [0]));

[0478] dp1 = xCalcDP(Rc[l]);

[0479] dql = xCalcDQ(Rc[l]);

[0480] d0 = dp0 + dq0;

[0481] dl = dp1 + dql;

[0482] d = d0 + dl.

[0483] in,

[0484] R C [N] corresponds to the chromaticity line perpendicular to the edge of the block being deblocked and at a distance N from the top of the current chromaticity segment being deblocked; and

[0485] In one example, when for R c [0] and R c [1] When ((abs(p3-p0)+abs(q3-q0)<(β>3))&&(d<(β>>2))&&(abs(q0-p0)<((tC*5+1)>>1))) is true, the second condition is true.

[0486] In one example, when for R c[0], when ((abs(p3-p0)+abs(q3-q0)<(β>3))&&(d<(β>>2))&&(abs(q0-p0)<((tC*5+1)>>1))) is true, the second condition is true.

[0487] It should be noted that, in one example, the edge is deblocked into segments, where the segment length can be a function of the minimum size allowed for CU / TU / PU / subPU. Furthermore, the chroma segment length can be 2 when 2×N and N×2 CUs are the shortest and thinnest blocks allowed in the chroma channel.

[0488] It should be noted that, according to the chroma filtering above, the two lines perpendicular to the edge being deblocked are processed into basic segments. In one example, four lines can be processed into basic segments. In one example, when four lines are processed into basic segments, the first condition can be true when d < β, where d is determined as follows:

[0489] dp0 = xCalcDP(R) c [0]);

[0490] dq0=xCalcDQ(R c [0]));

[0491] dp3=xCalcDP(R c [3]);

[0492] dq3=xCalcDQ(R c [3]);

[0493] d0 = dp0 + dq0;

[0494] d3 = dp3 + dq3;

[0495] d = d0 + d1.

[0496] Furthermore, in one example, when four lines are processed as basic segments, when for R... c [0] and R c [3] When ((abs(p3-p0)+abs(q3-q0)<(β>3))&&(d<(β>>2))&&(abs(q0-p0)<((tC*5+1)>>1))) is true, the second condition is true.

[0497] As described above, in ITU-T H.265, deblocking filters can be applied differently to CTU boundaries that coincide with slice and tile boundaries compared to CTU boundaries that do not coincide with slice and tile boundaries. Specifically, in ITU-T H.265, the `slice_loop_filter_across_slices_enabled_flag` enables / disables deblocking filters across CTU boundaries that coincide with the top and left slice boundaries. In one example, according to the techniques described herein, deblocking filters with supporting samples may not be allowed when the supporting samples of the deblocking filter exceed the boundary (e.g., image / slice / tile). In another example, according to the techniques described herein, when the supporting samples of the deblocking filter exceed the boundary (e.g., image / slice / tile) and the use of sample values ​​across the boundary (e.g., slice) is disabled, a padding operation can be used to generate supporting sample values. For example, one of the following can be used to generate support samples: scalar numeric filling, cyclic filling, copy filling, or symmetric filling. The scalar numeric filling operation fills based on a constant value, the cyclic filling operation fills with a cyclic repetition of sample values, the copy filling operation fills with repeated boundary sample values, and the symmetric filling operation fills with a mirror reflection of sample values.

[0498] As mentioned above, in ITU-T H.265, based on the value t C The filter value is clipped. Specifically, for the strong filter in ITU-TH.265 mentioned above, p i The value is clipped to (p) i -2*t C p i +2*t C And q i The value is clipped to (q) i -2*t C q i +2*t C As mentioned above, in ITU-T H.265, t C '(and therefore, t C The value of is determined based on the index Q, which is based on qP. L To determine, it equals: (QP) Q +QP P +1) / 2. In some cases of video coding (e.g., the proposed techniques for coding high dynamic range (HDR) video), the value of QP can be changed at the CU level or the CTU level. In these cases, the range of clipping operations based on index Q in ITU-T H.265 may be insufficient. In one example, according to the techniques described herein, different t values ​​can be determined for P-side samples and Q-side samples. C 'Value.' That is, the P-side t C'value, t CP 'and the corresponding P side t C value, t Cp It can be used for clipping p i 'Value and Q-side t C 'value, t CQ’ and corresponding Q-side t C value, t CQ It can be used for clipping q i 'Value.' In one example, the corresponding P-side index QQ p And Q-side index QQ q This can be achieved by using QP in the Q-index formula above. P and QP Q The corresponding value replaces qP L To determine. Therefore, according to the technique described in this paper, p i The value can be clipped to (p) i -2*t CP p i +2*t CP And q i The value can be clipped to (q) i -2*t CQ q i +2*t CQ It should be noted that p i ′ value and q i The value can include the filtered value generated according to any filter described herein. Therefore, the value used based on the corresponding t CP and t CQ Clipping p i 'value and q i The 'value' technique can be applied to any filter described in this article.

[0499] It should be noted that in some cases, a video block (e.g., a CU) may include an internal TU boundary, and block artifacts may appear within the video block. In some cases, when the video block has a size greater than 64, unblocking of internal TU boundaries may be disabled. In one example, according to the techniques described herein, even when the video block has a size greater than 64, unblocking can be performed along the video block boundary and also along any internal TU boundaries.

[0500] See Figures 5A to 5B In some cases, a P block or Q block may include multiple objects. For example, see Figure 5AIn one example, columns p7 to p3 may correspond to the first object, columns p2 to p0 to the second object, and columns q0 to q7 to the third object. In this case, when using samples from one or more columns p3 and q0 to q3 as support samples to filter samples in columns p2 to p0, the resulting filtered sample values ​​in columns p2 to p0 may appear blurry. Furthermore, in some cases, unblocking can cause tailing of the main sample values ​​and / or introduce other visual artifacts.

[0501] As described above, the corresponding solution block sample value y[n] with supporting samples can be specified based on the following equation:

[0502]

[0503] in,

[0504] The filter length is determined to be abs(a-b+1);

[0505] coeff[m] provides the filter tap values ​​(also known as filter coefficients);

[0506] x[n+m] provides the input sample values ​​corresponding to the supporting samples.

[0507] In one example, according to the techniques described herein, to avoid blurring or artifacts caused by different objects included in the filtered and support samples, one or more clipping operations can be applied to the term x[n+m]. In one example, the term x[n+m] can be clipped using Clip3(x[n]-2*t). C x[n]+2*t C , x[n+m]) replaces it.

[0508] In one example, if abs(x[n+m]-x[n]) is greater than the threshold, the term x[n+m] can be modified so that supporting samples x[n+m] are excluded from the sum. It should be noted that when coeff[m] corresponds to a uniform distribution (i.e., coeff[m] = 1 / filter length, where the filter length is equal to (abs(a-b+1)), coeff[m] is calculated as 1 / (filter length excluded samples). It should also be noted that when coeff[m] corresponds to a Gaussian distribution (i.e., ...

[0509]

[0510] The filter length is equal to abs(a-b+1)). In one example, the term x[n+m] can be modified such that for each support sample x[n+m] (where abs(x[n+m]-x[n]) is greater than the threshold), the value of the support sample x[n+m] is replaced by the value of x[n]. It should be noted that the threshold can be based on one or more of the following: a predefined value (e.g., 2 or 4), a value signaled in the parameter set, a value signaled in the slice header, a value based on the QP value (e.g., the QP value of the current sample and / or the support sample) and / or a value based on prediction information (e.g., the intra-frame prediction mode and / or motion information of the current sample and / or the support sample).

[0511] In one example, different filters can be applied at different sample locations relative to the boundary. For example, a strong filter can be used to filter samples near the boundary, and a weak filter can be used to filter samples far from the boundary. For example, samples in columns p0 to p1 can be filtered according to a strong filter, and samples in columns p2 to p4 can be filtered according to a weak filter. In one example, for chroma deblocking (or luma deblocking), a threshold (e.g., 2, 3, 4) can be used such that a strong filter is applied if the positional distance between the current sample and the sample closest to the boundary is less than the threshold. In one example, the threshold can be based on one or more of the following: the block size on each side (one or both sides) of the boundary; the boundary strength; the prediction mode used by the blocks on each side of the boundary; the prediction mode of the sample being deblocked; the QP of the sample being deblocked; the block size corresponding to the sample being deblocked; the block size corresponding to the sample being used for deblocking; the motion vector of the block being deblocked on each side of the boundary; the motion vector for the sample being deblocked; and / or the motion vector for the sample being used for deblocking.

[0512] It should be noted that in some cases of video coding, the luminance transform coefficients corresponding to the CU (e.g., after quantization) can be 0, and the CU can be divided into sub-PUs (e.g., ATMVPs) for motion compensation. In this case, according to the techniques described herein, in some examples, luminance deblocking can be performed along the sub-PU boundaries and further along the CU boundaries.

[0513] It should be noted that in some cases of video coding, the chroma transform coefficients corresponding to the CU (e.g., after quantization) can be 0, and the CU can be divided into sub-PUs (e.g., ATMVPs) for motion compensation. In this case, according to the techniques described herein, in some examples, chroma deblocking can be performed along the sub-PU boundaries and further along the CU boundaries.

[0514] As mentioned above, in ITU-T H.265, for luminance, Bs, t CEach of β and d is used to determine which type of filter to apply (e.g., a strong filter or a weak filter). Specifically, if d is less than β, the variable dStrong is determined as follows:

[0515] d_strong=abs(p3-p0)+abs(q0-q3)

[0516] The following determines whether to apply a strong or weak filter based on the value of d_strong:

[0517] -If ((d_strong<(β>>3))&&(d<(β>>2))&&(abs(p0-q0)<than(5*tC+1)>>1),

[0518] - Apply a strong filter;

[0519] -otherwise,

[0520] - Apply a weak filter.

[0521] In one example, according to the techniques described in this paper, dStrong can be determined as follows:

[0522] d_strong=(bSidePisLarge?max(abs(p0-p7), max(abs(p3-p0), abs(p7-p3))): abs(p3-p0))+(bSideQisLarge? Max(abs(q0-q7), max(abs(q3-q0), abs(q7-q3))): abs(q3-q0));

[0523] Regarding the specific implementation of the deblocking filter in JEM, luma deblocking cannot be performed in parallel when one of the following conditions is met, as shown below. That is, for example, deblocking may not be performed in parallel on the left and right vertical boundaries of a block, or on the top and bottom horizontal boundaries of a block. In other words, deblocking cannot be performed in parallel on two block boundaries because the filtering process at one boundary may involve samples deblocked by the filtering process at the other boundary. Therefore, samples at the center of a block may be covered by two deblocking filters at each corresponding edge.

[0524] If (Cur_EDGE_VER && cur_block_width == 4), then the current block's vertical boundary will not be solved in parallel;

[0525] If (Cur_EDGE_VER && adjacent_block_width == 4), then the vertical boundaries of adjacent blocks will not be solved in parallel;

[0526] If (Cur_EDGE_HOR && cur_block_height == 4), then the current block's horizontal boundary will not be solved in parallel;

[0527] If (Cur_EDGE_HOR && adjacent_block_width == 4), then the horizontal boundaries of adjacent blocks will not be solved in parallel;

[0528] in,

[0529] Cur_EDGE_VER is the current vertical boundary, Cur_EDGE_HOR is the current horizontal boundary, cur_block_width is, for example, the current block width in the luminance sample, cur_block_height is, for example, the current block height in the luminance sample, adjacent_block_width is, for example, the width of the adjacent block in the luminance sample, and adjacent_block_height is, for example, the height of the adjacent block in the luminance sample.

[0530] In one example, according to the techniques described herein, for each of the above conditions, unblocking can be performed on the brightness samples at the boundary as follows:

[0531] If (Cur_EDGE_VER && cur_block_width == 4 && adjacent_block_width > 4), then for Cur_EDGE_VER, only the adjacent block samples are deblocked;

[0532] If (Cur_EDGE_VER && cur_block_width == 4 && adjacent_block_width == 4), then unblocking is not performed for Cur_EDGE_VER;

[0533] If (Cur_EDGE_VER && cur_block_width > 4 && adjacent_block_width == 4), then for Cur_EDGE_VER, only the current block sample is deblocked;

[0534] If (Cur_EDGE_VER && cur_block_width > 4 && adjacent_block_width > 4), then for Cur_EDGE_VER, unblocking is performed on the current block sample and the adjacent block samples;

[0535] If (Cur_EDGE_HOR && cur_block_height == 4 && adjacent_block_height > 4), then for Cur_EDGE_HOR, only the adjacent block samples are deblocked;

[0536] If (Cur_EDGE_HOR && cur_block_height == 4 && adjacent_block_height == 4), then Cur_EDGE_HOR will not perform unblocking.

[0537] If (Cur_EDGE_HOR && cur_block_height > 4 && adjacent_block_height == 4), then for Cur_EDGE_HOR, only the current block sample is deblocked;

[0538] If (Cur_EDGE_HOR&&cur_block_height>4&&adjacent_block_height>4), then for Cur_EDGE_HOR, unblocking is performed on the current block sample and the adjacent block samples.

[0539] Similar to the method described above, for chroma deblocking, a limitation on parallel deblocking occurs when the corresponding `cur_block_height`, `adjacent_block_height`, `cur_block_width`, and `adjacent_block_width` are equal to threshold 2. Therefore, according to the technique described in this paper, for chroma samples, deblocking can be performed as described above, where threshold 4 is replaced by threshold 2 in the conditional statement.

[0540] In one example, according to the technique described in this paper, instead of performing deblocking on the edges for blocks with a size less than or equal to the threshold, a narrower filter can be applied to samples at the edges. For example, in the case of (Cur_EDGE_VER && cur_block_width == 4 && adjacent_block_width > 4), deblocking can be performed as follows:

[0541] For Cur_EDGE_VER, deblocking is performed on adjacent block samples based on the filter width, and deblocking is performed on an adjacent column of the sample at Cur_EDGE_VER for the current block.

[0542] Similarly, for each of the above cases, a narrower filter can be applied to samples at the edges. Therefore, in general, according to the techniques described herein, a video encoder (and / or video decoder) can be configured to determine when parallel deblocking is limited, for example, due to overlapping deblocking filters (e.g., filter widths greater than half the width (or height) of the block), and modify the samples that would otherwise be deblocked. It should be noted that in some cases, parallel deblocking can be limited based on the samples used for deblocking support. According to the techniques described herein, a video encoder (and / or video decoder) can be configured to determine when parallel deblocking is limited to samples in a block that can be used to deblock multiple deblocking filters.

[0543] As mentioned above, for an F4P P-side filter, one of the calculations includes:

[0544] p0'=(p7+p6+p5+p4+p3+p2 + p1+2*p0+q0+q1+q2+q3+q4+q s +q6+8>>4

[0545] It should be noted that if the size of the q-side is 8, and the edge opposite the current edge uses a strong HEVC filter, then samples q5 and q6 can be modified by a strong HEVC unblocking operation on the opposite side. Unblocking edges that are parallel to each other cannot be processed in parallel. In one example, to prevent this, the p-side should only use a long filter (i.e., a stronger filter) if the q-side length (perpendicular to the edge) is greater than or equal to 16. Check this condition (e.g., the LargeBlk condition) in one of the following ways:

[0546] LargeBlk condition: (The lengths of both sides of the edge perpendicular to the edge are both >= 16)?

[0547] TRUE: FALSE;

[0548] LargeBlk condition: (The lengths of both sides of the edge perpendicular to the edge are both >= 32)?

[0549] TRUE: FALSE;

[0550] OR

[0551] LargeBlk condition: (The length of the large block side perpendicular to the edge is >= 32 AND the length of the other block sides perpendicular to the edge is >= 16)? TRUE: FALSE. Note that when two block sizes are the same length, we will require both to be >= 32. A wider, stronger filter is only used for the side with a length >= 32.

[0552] In one example, according to the technique described in this paper, a set of unblocking filters can utilize bilinear operations. In one example, for i = 0 to S-1, the block boundary sample p i and q i The following is replaced by linear interpolation.

[0553] p i ′=(f i *Middle s,t +(64-f i )*P s +32)>>6), clipping is p i ±t C

[0554] q i '=(g i *Middle s,t +(64-g i )*Q t +32)>>6), clipping is q i +t C

[0555] In one example, f can be determined as provided in Table 1. i Middle s,t P s g i and Q t .

[0556]

[0557] Table 1

[0558] Referring to Table 1, it should be noted that for 7, 5, 7, 3, 5, 3, 5, 7 and 3, 7, the values ​​of pi and q for Middle are... i The weights are not the same, and are derived from 7,7 by adding another item.

[0559] In one example, according to the techniques described in this paper, a set of unblocking filters can utilize bilinear operations if either side is greater than or equal to 32.

[0560] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 2 when either side is greater than or equal to 32.

[0561] P side Q side s,t ＞＝32 ＞＝32 7，7 ＞＝32 ＜32 7，3 ＜32 ＞＝32 3，7

[0562] Table 2

[0563] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 3 when either side is greater than or equal to 32.

[0564] P side Q side s,t ＞＝32 ＞＝32 7，7 ＞＝32 ＜32 7，5 ＜32 ＞＝32 5，7

[0565] Table 3

[0566] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 4 when either side is greater than or equal to 32.

[0567] P side Q side s,t ＞＝32 ＞＝32 5，5 ＞＝32 ＜32 5.3 ＜32 ＞＝32 3.5

[0568] Table 4

[0569] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 5 when either side is greater than or equal to 32.

[0570] P side Q side st ＞＝32 ＞＝32 7，7 ＞＝32 ＜32 7，3 ＜32 ＞＝32 3，7 ＜32 ＜32 3，3

[0571] Table 5

[0572] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 6 when either side is greater than or equal to 32.

[0573] P side Q side s,t ＞＝32 ＞＝32 7，7 ＞＝32 ＜32 7，5 ＜32 ＞＝32 5，7 ＜32 ＜32 5，5

[0574] Table 6

[0575] In one example, according to the technique, bilinear unblocking can be performed as provided in Table 7 when either side is greater than or equal to 32.

[0576] P side Q side s,t ＞＝32 ＞＝32 5，5 ＞＝32 ＜32 5，3 ＜32 ＞＝32 3，5 ＜32 ＜32 3，3

[0577] Table 7

[0578] In one example, according to the techniques described herein, a set of deblocking filters can utilize bilinear operations if either side is greater than or equal to 16. In this case, 32 can be replaced by 16 in Tables 2-7. In one example of Tables 5, 6, and 7, the last column (s, t) in a row where the length of the P-side is not equal to the length of the Q-side can be filtered using the corresponding (3, 3), (5, 5), and (3, 3). In one example, whether a set of deblocking filters utilizes bilinear operations can be further conditional on whether a strong filter condition is true. For example, any of the strong filter conditions mentioned above. In one example, whether a set of deblocking filters utilizes bilinear operations can be further conditional on the following:

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

[0580] dp0 = abs(p 2，0 -2*p 1，0 +p 0，0 )

[0581] dp3 = abs(p 2，3 -2*p 1，3 +p 0，3 )

[0582] dq0=abs(q 2，0 -2*q 1，0 +q 0.0 )

[0583] dq3=abs(q 2，3 -2*q 1，3 +q 0，3 )

[0584] Then,

[0585] If (p-side is greater than or equal to 16)

[0586] dp0=(dp0+abs(p 5，0 -2*p 4,0 +p 3.0 )+1)>>1

[0587] dp3=(dp3+abs(p 5，3 -2*P 4，3 +p 3，3 )+1)>>1

[0588] If (q-side is greater than or equal to 16)

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

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

[0591] dpq0=dp0+dq0

[0592] dpq3=dp3+dq3

[0593] dp = dp0 + dp3

[0594] dq = dq0 + dq3

[0595] d = dpq0 + dpq3

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

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

[0598] sp3 = abs(p3 - p0)

[0599] If (p-side is greater than or equal to 16)

[0600] sp3=(sp3+abs(p7-p3)+1)>>1

[0601] sq3 = abs(q3 - q0)

[0602] If (q-side is greater than or equal to 16)

[0603] sq3=(sq3+abs(q7-q3)+1)>>1

[0604] StrongFilterCondition = (dpq < (β >> 2), sp3 + sq3 < (β >> 3), and abs(p0 - q0) < (5 * t) C +1)>>1)? TRUE: FALSE

[0605] It should be noted that in some examples: the control parameter values ​​for luma and chroma (e.g., β, tC, etc.) may be different and signaled using different sets of syntax elements; the control parameter values ​​for chroma may be derived from the control parameter values ​​for luma; deblocking may be performed only on the edges of sub-PUs aligned with the 8×8 (luma) and 4×4 (chroma) boundaries; deblocking of the current block's edges may be based on the use of linear model (LM) chroma; deblocking of the current block's edges may be based on the use of a separate partition tree; deblocking of the current block's edges may be based on the use of pulse code modulation (PCM); and / or deblocking of the current block's edges may be based on the use of transform quantization bypass mode. It should be pointed out that PCM is a lossless coding mode for sample blocks. In examples of PCM encoding, samples are directly represented by a predefined number of bits. The bit depth used for PCM can be signaled in the parameter set.

[0606] Regarding the use of LM chroma to unblock the edges of the current block and / or the unblocking of the edges of the current block can be based on the use of a separate partitioning tree, in one example, unblocking can be performed on the edges of the current block when LM chroma is used for the chroma block and / or a separate tree is used for both luma and chroma and / or the received transform coefficients are zero. In one example, for a separate tree, unblocking can be performed only on chroma edges that coincide with the 4×4 chroma grid (e.g., TU edges, PU edges, sub-PU edges, CU edges).

[0607] In one example, NS00P and NS00Q are used to unblock edges when the block condition is not TRUE and the strong filter condition is TRUE.

[0608] In one example, when the block condition is not TRUE and the strong filter condition is TRUE, the (s,t) = 3,3 filter is used to unblock the edges.

[0609] It should be noted that in some cases, the unblocking boundary may include a horizontal CTU boundary. For example, see [link to relevant documentation]. Figure 5B In some cases, samples py,x can be included in a CTU that is above the CTU containing samples qy,x. To encode the top line in the current CTU, a typical video encoder implementation stores N rows of samples in the bottom line of the CTU above the current CTU. For example, in Figure 5B In the case where the deblocking boundary is the CTU boundary, the video encoder stores the value px,0 used to perform intra-frame predictive coding for line qx,0. The CTU line buffer refers to the lines of sample values ​​above the current CTU, which are stored for encoding the current CTU. As the number of lines included in the CTU line buffer increases, the storage cost of the video encoder implementation increases. It should be noted that in some cases, data corresponding to the sample values ​​(e.g., prediction mode (and associated information such as intra-frame prediction mode, bidirectional / unidirectional prediction, motion vectors, reference indexes, etc.), block size, coefficient coding markers, etc.) are also stored. Therefore, to avoid increasing implementation costs, it is desirable to avoid increasing the number of lines included in the CTU line buffer solely for the purpose of performing deblocking. For example, if all coding features of the proposed video coding standard require a CTU line buffer to store sample values ​​for four lines, then adding a CTU line buffer to store sample values ​​for seven lines of deblocking filters would increase implementation costs.

[0610] As mentioned above, JEM describes the coding characteristics studied by JVET under the Harmonized Test Model as potential enhanced video coding techniques that exceed the capabilities of ITU-T H.265. Furthermore, in response to the "Joint Call for Proposals on Video Compression with Capabilities beyond HEVC" jointly published by VCEG and MPEG, various groups presented multiple descriptions of video coding at the 10th meeting of ISO / IEC JTC1 / SC29 / WG11 held in San Diego, California (April 16-20, 2018).

[0611] As a result of various descriptions of video coding, the draft text of the video coding specification was described in "Versatile Video Coding (Draft 1)," namely document JVET-J1001-v2, presented at the 10th meeting of ISO / IEC JTC1 / SC29 / WG11 held in San Diego, California, April 16-20, 2018. This document is incorporated herein by reference and referred to as JVET-J1001. "Versatile Video Coding (Draft 2)," namely document JVET-K1001-v4, presented at the 11th meeting of ISO / IEC JTC1 / SC29 / WG11 held in Ljubljana, Slovenia, July 10-18, 2018, is an update to JVET-J1001, also incorporated herein by reference and referred to as JVET-K1001. The techniques proposed in each of JVET-J1001 and JVET-K1001 are being implemented and evaluated using a test model (VTM) and a benchmark set (BMS). The existing unblocking filter in the BMS modifies up to three samples perpendicular to the edge.

[0612] The document “CE2-related: Longer Tap Deblocking Filter” (JVET-K0369-r3, referred to herein as JVET-K0369), presented at the 11th meeting of ISO / IEC JTC 1 / SC29 / WG11 held in Ljubljana, Slovenia, from July 10 to 18, 2018, describes a deblocking filter that modifies up to seven samples perpendicular to the deblocked edge. Furthermore, to limit the CTU line buffer size, the filter described in JVET-K0369 restricts filtering operations at horizontal edges overlapping with the CTU boundary. Specifically, JVET-K0369 describes a deblocking filter that modifies sample values ​​according to Table 8A and provides the locations for modifying the deblocking filter at horizontal edges overlapping with the CTU boundary as shown in Table 8B.

[0613]

[0614] Table 8A

[0615]

[0616] Table 8B

[0617] It should be noted that JVET-K0369 provides a line buffer requirement for modifying the deblocking filter for horizontal edges overlapping with CTU boundaries without degrading chroma sample values. Furthermore, as shown in Table 8B, in addition to "zeroing" the filter coefficients from p7 to p4, the filter coefficient values ​​from p3 to q7 are also changed. Therefore, JVET-K0369 requires storage of an additional filter bank for filtering CTU boundaries, which necessitates additional memory for storing the coefficients.

[0618] In one example, according to the techniques described herein, the use of long-tap filters can be restricted. This may include modifications and / or filters with filter support that support at least three or more lines from px,0 to px,i. In one example, for luma and / or chroma deblocking, a long-tap filter is not applied to the P side if the following condition is met (EDGE TYPE is EDGE HOR && current boundary is aligned with CTU boundary), where EDGE TYPE is EDGE HOR, indicating that the current boundary is a horizontal boundary. In one example, for luma and / or chroma deblocking, a long-tap filter is not applied to P if the following condition is met (EDGE_TYPE is EDGE_HOR && CTUSize in curPos.y% of the luma sample == 0), where curPos.y is the vertical luma position of the current block to be deblocked. In one example, for luma and / or chroma deblocking, a long tap filter is not applied to the P side if the following condition is met (EDGE_TYPE is EDGE_HOR && CTUSize in the chroma sample curPosC.y == 0), where curPosC.y is the vertical chroma position of the current block to be deblocked. In one example, for luma and / or chroma deblocking, a long tap filter is not applied to the Q and P sides if the following condition is met (EDGE_TYPE is EDGE_HOR && the current boundary is aligned with the CTU boundary). In one example, for luma and / or chroma deblocking, a long tap filter is not applied to the Q and P sides if the following condition is met (EDGE_TYPE is EDGE_HOR && CTUSize in the luma sample curPos.y == 0). In one example, for luma and / or chroma unblocking, a long-tap filter is not applied to the Q-side and P-side if the following condition is met (EDGE TYPE is EDGE HOR && curPosC.y% CTUSize in the chroma sample == 0). In one example, when a long-tap filter is not applied, another filter is applied that modifies fewer samples and / or includes a filter supported by fewer lines (e.g., one, two, or three lines) from px,0 to px,i. For example, the weak or strong filters described herein can be applied in situations where the application of a long-tap filter is not permitted. It should be noted that, as provided in ITU-T H.265, the % operand is modulo the operand, providing the remainder when x is divided by y.

[0619] In one example, when a long-tap filter is not applied, sample values ​​exceeding the target line buffer threshold (e.g., three or four) may be unavailable, and predetermined values ​​are available for the corresponding sample locations. Table 9 shows an example where the long-tap filter includes the long-tap filter described above relative to Table 8A, and the target line buffer threshold is four. Therefore, sample values ​​for p4 through p7 are unavailable. As shown in Table 9, the values ​​for p4 through p7 are not modified for deblocking. Furthermore, as shown in Table 9, the filter coefficients for p4 through p7 are represented as NA, which indicates that the sample value for each of p4 through p7 in the line buffer is unavailable. In one example, for each p4 through p7, the sample value can be set to the sample value of p3, and the filter coefficients in Table 8A can be used to derive the modified sample values ​​for p3′ through q2′.

[0620]

[0621] Table 9

[0622] Furthermore, in one example, values ​​derived from the available sample values ​​can be used for the corresponding sample locations. In one example, for each p4 to p7, the sample values ​​can be set as the average sample values ​​of p3 and p2, and the filter coefficients in Table 8A can be used to derive the modified sample values ​​for p3′ to q2′.

[0623] In one example, when long-tap filters are not applied, the filtering process can be modified based on the location of the sample being deblocked (e.g., based on whether the sample value is above the CTU horizontal boundary or within a specific distance of the CTU horizontal boundary), and corresponding filters can be selected to not access / deblock samples exceeding the target line buffer threshold. For example, regarding the example shown in Table 9, different rules can be applied for p3′ and p2′ by deriving the sample values ​​of p4 through p7.

[0624] In one example, when a long-tap filter is not applied, the control process can be modified based on the location of the sample being deblocked, and the corresponding filter for samples that are not accessed / deblocked beyond the target line buffer threshold can be selected. For example, the luminance (s=3, t=7) filter in Table 1, the luminance (s=3, t=5) filter in Table 1, the luminance F1P filter, and / or the chrominance weak filter can be selected.

[0625] In one example, when no long-tap filter is applied, the unblocking mesh can be modified so that samples exceeding the target line buffer threshold are not accessed / unblocked. For example, the unblocking mesh can be moved so that the horizontal edge is at a distance of 4 below the horizontal CTU edge.

[0626] As described above, in ITU-T H.265, variables tC' and β' are determined based on the QP value used to encode the CB, which includes video blocks P and Q (which may be referred to as QPP and QPQ). The derivation of the index Q for the luminance channel was described above. For the chrominance channel, ITU-T H.265 specifies that if the chrominance is equal to 4:2:0, then based on the exponent qPi, as follows: Figure 13 The variable QpC is determined as specified in the table shown:

[0627] qPi=((Qp Q +Qp p +1)>>1)+cQpPicOffset

[0628] in,

[0629] cQpPicOffset is a variable that specifies the offset of the image-level color metric parameter, and

[0630] For Cb, cQpPicOffset = pps_cb_qp_offset, and

[0631] For Cr, cQpPicOffset = pps_cr_qp_offset

[0632] It should be noted that in ITU-T H.265, if the chroma format is equal to 4:2:2 or 4:4:4, then QpC is set to equal to Min(qPi, 51).

[0633] For chroma, use Figure 6 The table shown determines t C ', and the following applies to t C Determine index Q:

[0634] Q = Clip3(0, 53, Q) pc +2*+(slice_tc_offset_div2<<1))

[0635] The techniques proposed in each of JVET-J1001 and JVET-K1001 provide for cases where separate partition trees can be used to partition the luma and chroma channels. When using separate partition trees to partition the luma and chroma channels, increasing the QP value of the chroma channel relative to the amount of change in the QP value of the luma channel may be useful. That is, for example, the corresponding QP offset value for each component of the chroma channel can be increased, and this offset value can be signaled at the slice level. It should be noted that ITU-H.265 provides the following chroma channel QP offset syntax elements: pps_cb_qp_offset and pps_cr_qp_offset specify the offsets used to derive the luma quantization parameters Qp′Y for Qp′Cb and Qp′Cr, respectively. The values ​​of pps_cb_qp_offset and pps_cr_qp_offset should be in the range of -12 to +12 (inclusive). When ChromaArrayType equals 0, pps_cb_qp_offset and pps_cr_qp_offset are not used during decoding, and the decoder should ignore their values.

[0636] When determining the value of the Qp′Cb quantization parameter, slice_cb_qp_offset specifies the difference to be added to pps_cb_qp_offset. The value of slice_cb_qp_offset should be in the range of -12 to +12 (inclusive). If slice_cb_qp_offset does not exist, it is inferred to be equal to 0. The value of pps_cb_qp_offset + slice_cb_qp_offset should be in the range of -12 to +12 (inclusive).

[0637] When determining the value of the Qp′Cr quantization parameter, slice_cr_qp_offset specifies the difference to be added to the value of pps_cr_qp_offset. The value of slice_cr_qp_offset should be in the range of -12 to +12 (inclusive). If slice_cr_qp_offset does not exist, it is inferred to be equal to 0. The value of pps_cr_qp_offset + slice_cr_qp_offset should be in the range of -12 to +12 (inclusive).

[0638] When unblocking parameters are based on QP values, changes to the derivation of chroma QP values ​​can affect chroma channel unblocking. According to the techniques described herein, the derivation of unblocking parameters based on QP values ​​can be modified, for example, in cases where separate partition trees can be used to partition the luminance and chroma channels.

[0639] In one example, according to the techniques described in this paper, cQpPicOffset can be derived as follows:

[0640] For Cb, cQpPicOffset = pps_cb_qp_offset + slice_cb_qp_offset, and

[0641] For Cr, cQpPicOffset = pps_cr_qp_offset + slice_cr_qp_offset

[0642] In one example, the CU-level chroma QP offset value can be signaled (e.g., during palette mode encoding). The chroma QP derivation for unblocking can utilize the CU-level chroma QP offset. For example, if the variables CuQpOffsetCb and CuQpOffsetCr represent the Cb and Cr offsets, the chroma QP offset can be derived as:

[0643] For Cb, cQpPicOffset = pps_cb_qp_offset + slice_cb_qp_offset + CuQpOffsetcb

[0644] For Cr, cQpPicOffset = pps_cr_qp_offset + slice_cr_qp_offset + CuQpOffsetcr

[0645] In some cases, additional luma and chromaticity QP offset values ​​can be used for blocks undergoing a type of processing (e.g., adaptive color transformation). These QP offsets can be used to derive the luma and chromaticity QPs. Therefore, the unblocking process can depend on the additional luma and chromaticity QP offsets.

[0646] In some examples, when using separate partition trees to divide the luminance and chrominance channels, the chrominance QP value can be calculated based on the partition tree type. For example, in one example, the chrominance QP value can be determined as follows:

[0647] qPi=((QP blk_Q +QP blk_P +1)>>1)+cQpPicOffset

[0648] Among them, QP blk_P QP blk_Q These are the luminance quantization parameters corresponding to the chroma blocks on the P-side and the chroma blocks on the Q-side, respectively.

[0649] In one example, QP blk_P and / or QP blk_W The QP values ​​of multiple corresponding luminance blocks can be derived from one or more of the following combinations;

[0650] The number of samples corresponding to the luminance blocks of the chroma block; the luminance QP value corresponding to the predetermined chroma position. In some examples, QP... blk_P and / or QP blk_Q Function derivation can be used, such as integer average and maximum value functions with floor functions. It should be noted that it is possible to have partial luminance blocks corresponding to chroma blocks. Figures 14A to 14B An example of possible luminance divisions corresponding to chromaticity blocks P and Q is shown, where each luminance block has a QP value QP_X. Figure 14A In the example shown, chroma block P is juxtaposed with luma blocks having QP values ​​QP_1 and QP_3, and chroma block Q is juxtaposed with luma blocks having QP values ​​QP_2 and QP_4. Figure 14B In the example shown, chroma block P is juxtaposed with luma blocks having QP values ​​QP_1, QP_3, and QP_5, and chroma block Q is juxtaposed with luma blocks having QP values ​​QP_2 and QP_4. In one example, for Figure 14A The example shown is Qp blk_P and QP blk_Q The following derivation can be made:

[0651] QP blk_P = (QP_1 + QP_3 + 1) >> 1

[0652] QP bik_Q = (QP_2 + QP_4 + 1) >> 1

[0653] In one example, for Figure 14B The example shown is QP blk_P and Qp blk_Q The following derivation can be made:

[0654] Qp blk_P =(QP_1+QP_5+2*QP_3+2)>>1

[0655] QP blk_Q (QP_2+QP_4+1)>>1

[0656] In one example, QP blk_P and / or QP blk_Q This can be derived by identifying a set of chromaticity locations and, for each chromaticity location, its corresponding luminance location. For each corresponding luminance location, the corresponding QP value can be determined. The corresponding QP value can then be used to derive Qp. blk_P and / or QP blk_Q .

[0657] As described above, in one example, a wider strong filter condition may include whether both the first and second conditions are true, where the first condition may be true when d < β, and d is determined as follows:

[0658] dp0 = xCalcDP(R) c [0]);

[0659] dq0=xCalcDQ(Rc[0]));

[0660] dp1 = xCalcDP(Rc[l]);

[0661] dq1=xCalcDQ(R c [1]);

[0662] d0 = dp0 + dq0;

[0663] dl = dp1 + dq1;

[0664] d = d0 + d1.

[0665] in,

[0666] R C [N] corresponds to the chromaticity line perpendicular to the edge of the block being deblocked and at a distance N from the top of the current chromaticity segment being deblocked; and in one example, the filter condition may include a condition that is true when d < β, where d is determined as follows:

[0667] dp0 = xCalcDP(Rc[0]);

[0668] dq0=xCalcDQ(Rc[0]));

[0669] d0 = dp0 + dq0;

[0670] d = d0 + d1.

[0671] In some examples, the condition for x sample segments of the chroma block boundary can be checked (e.g., x = 2). This reduces the number of lines for which gradients need to be computed in the worst case. It should be noted that in the worst case, the first condition will compute the gradient (xCalcDQP per line), while the above condition will compute the gradient once every 2 lines.

[0672] As mentioned above, ITU-T H.265, variables β and t C Used for filtering decisions and clipping operations. For example, β and / or t C The sample values ​​used to determine whether to use a strong filter and / or for clipping are filtered. It should be noted that in JVET-K1001, the peak signal-to-noise ratio (PSNR) is higher than that of ITU-T H.265 for a given quantization level. Therefore, in some cases, β and / or t are modified. CThis can be useful for modifying the deblocking strength. That is, if the distortion level is low at a given quantization level, the perceived blocking effect is low, and therefore less deblocking is needed. In one example, β can be modified as follows: β = β << n. In another example, β can be modified as follows: β = β >> n. In yet another example, t can be modified as follows: C :t C =t C << n. In one example, t can be modified as follows: C :t C =t C >>n. In one example, n can be determined based on one or more of the following combinations: slice type, QP value, block size, bit depth, intra-frame prediction mode, motion vector (e.g., magnitude), channel type, and / or component type. For example, in one example, t C =t C >>2 can be used for intra-frame slices, and t C =t C >>4 can be used for inter-frame slicing. In one example, t C =t C >>2 can be used for the luminance component, and t C =t C >>4 can be used for chromaticity components.

[0673] The document “CE2-2.1.1: Long deblocking filters and fixes” (referred to herein as JVET-K0307-vl), presented at the 11th meeting of ISO / IEC JTC1 / SC29 / WG11 held in Ljubljana, Slovenia, from July 10 to 18, 2018, describes long filters and decisions for the luminance component.

[0674] Based on the aforementioned filtering techniques, the filtering techniques in JVET-K0307 can be modified to enable the use of long asymmetric filters. For long asymmetric filters, the number of samples unblocking on the larger block side is greater than the number of samples unblocking on the smaller block side. The unblocking decision process selected from this extended filter bank is described in detail below. This extended filter bank can be used for strong unblocking throughout the unblocking process.

[0675] In one example, according to the technique described herein, a brighter filter is used when either side has a large block and the modified strong filter condition is met. In one example, the bright block corresponds to a width >= 32 for the vertical edge and a height >= 32 for the horizontal edge.

[0676] In one example, a brighter filter can be defined as follows:

[0677] Then, for i = 0 to S-1, the block boundary sample p i and q i The following can be replaced by linear interpolation:

[0678] .'=+*+32)>>6), clipping is ±t C

[0679] .'=+*+32)>>6), clipping is ±t C

[0680] Where f_i, Middle_s, t, P_s, and Q_s are given in Table 10 below:

[0681]

[0682] Table 10

[0683] In one example, the control process is also based on the gradient calculated for two lines across four sample segments; the absolute pixel value difference and t C The comparison includes the differences between absolute pixel values ​​and β, as well as comparisons with other absolute pixel value differences. More gradients are calculated for larger blocks. The control process can be as follows:

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

[0685] First, derive dp0, dp3, dq0, and dq3 as described in ITU-T H.265.

[0686] Then, as in ITU-T H.265, dpq0, dpq3, dp, dq, and d are derived.

[0687] As in ITU-T H.265, when d is less than β, the following ordered steps are applied:

[0688] a. Derive dpq as in ITU-T H.265.

[0689] b.sp3-Abs(p3-p0), derived as in ITU-TH.265.

[0690] If (p-side is greater than or equal to 32)

[0691] sp3=(sp3+Abs(p7-p3)+1)>>1

[0692] c.sp3 = Abs(q0-q3), derived as in ITU-T H.265.

[0693] If (q-side is greater than or equal to 32)

[0694] sq3=(sq3+Abs(q7-q3)+1)>>1

[0695] d. As derived in ITU-T H.265, StrongFilterCondition = (dpq < (β >> 2), sp3 + sq3 < ((p-side or q-side > or equal to 32) ? (3 * β >> 5) : (β >> 3)), and Abs(p0 - q0) < (5 * t C +1)>>1)? TRUE: FALSE

[0696] e. If (p-side or q-side) is greater than or equal to 32

[0697] Set dSp1 and dSp2 to Abs(p3-p0).

[0698] Set dSq1 and dSq2 to Abs(q3-q0).

[0699] If (q-side is greater than or equal to 32)

[0700] dSq1=abs(q4-2*q2+q0)

[0701] dSq2=abs(q6-2*q3+q0)

[0702] If (p-side is greater than or equal to 32)

[0703] dSp1=abs(p4-2*p2+p0)

[0704] dSp2=abs(p6-2*p3+p0)

[0705] The following calculations are performed for d_strong1 and d_strong2:

[0706] d_strong1=dSp1+dSq1

[0707] d_strong2=dSp2+dSq2

[0708] Calculate StrongFilterCondition=(StrongFilterCondition&&((d_strong1<((3*beta)>>5))&&(d_strong2<((3*beta)>>5))))? TRUE:FALSE

[0709] f. When StrongFilterCondition is TRUE, use a brighter filter (which can be selected based on the block size at the edge boundary).

[0710] In one example, the control process can be as follows:

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

[0712] First, derive dp0, dp3, dq0, and dq3 as described in ITU-T H.265.

[0713] Then, as in ITU-T H.265, dpq0, dpq3, dp, dq, and d are derived.

[0714] As in ITU-T H.265, when d is less than β, the following ordered steps are applied:

[0715] As in ITU-T H.265, dpq is derived.

[0716] sp3 = Abs(p3-p0), derived as in ITU-T H.265.

[0717] If (p-side is greater than or equal to 32 && q-side is greater than or equal to 16)

[0718] sp3=(sp3+Abs(p7-p3)+1)>>1

[0719] sq3 = Abs(q0-q3), derived as in ITU-T H.265.

[0720] If (q-side is greater than or equal to 32 && p-side is greater than or equal to 16)

[0721] sq3=(sq3+Abs(q7-q3)+1)>>1

[0722] As derived in ITU-T H.265, StrongFilterCondition = (dpq < (β >> 2), sp3 + sq3 < ((p side > or equal to 32 && q side > or equal to 16)) OR (q side > or equal to 32 && p side > or equal to 16)) ? (3 * β >> 5) : (β >> 3)), and Abs(p0 - q0) < (5 * t) C +1)>>1)? TRUE: FALSE

[0723] It should be noted that the conditions (p-side greater than or equal to 32 && q-side greater than or equal to 16) and (q-side greater than or equal to 32 && p-side greater than or equal to 16) determine whether a brighter filter can be applied. It should also be noted that in other examples, additional conditions (e.g., one or more previous conditions) can be used to determine whether a brighter filter can be applied. In one example, the additional conditions might be as follows:

[0724] If (p-side ≥ 32 && q-side ≥ 16) || (q-side ≥ 32 && p-side ≥ 16); however, for (7, 7, 7, 3, 3, 7), the decision process is (p-side ≥ 32 || q-side ≥ 32). The idea is that a lower threshold of 3*β >> 5 instead of β >> 3 is suitable for any of these brighter filters before the decision process.

[0725] In one example, according to the technique described herein, luminance can be deblocked based on a 4×4 luminance sample grid (or, in some examples, an 8×8 luminance sample grid). In this example, the luminance-strength filters described above as the WS00P P-side filter and the WS00Q Q-side filter can be used for large blocks, where large blocks correspond to a width >= 32 for the vertical edge, a height >= 32 for the horizontal edge, and adjacent blocks greater than or equal to 16. The control process can also be based on gradients calculated for two lines across four sample segments; the absolute pixel value difference and t C The comparison of p0 with β, and the comparison of other absolute pixel value differences with β, are described in further detail below. Additionally, when p0 belongs to a CTU higher than the current CTU, the following limited-support luminance filters provided in Table 8B above can be used.

[0726] In some cases, a subset of the samples may not be accessible. In such cases, the control process that uses that subset of samples may be affected. This can lead to asymmetry in gradient computation. In some examples, an alternative control process can be used in this situation.

[0727] In one example, the control process can be as follows:

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

[0729] First, derive dp0, dp3, dq0, and dq3 as described in ITU-T H.265.

[0730] LongTapDeblocking = ((pside>=32&&qside>=16)||(pside>=16&&qside>=32)))?

[0731] TRUE: FALSE

[0732] ControlSamplesAccessible = p0 Does this mean it belongs to a CTU higher than the current CTU? FALSE: TRUE

[0733] If (LongTapDeblocking)

[0734] If (p side is greater than or equal to 32 && ControlSamplesAccessible)

[0735] dp0=(dp0+Abs(p 5.0 -2*p 4,0 +p 3,0 )+1)>>1

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

[0737] If (q-side is greater than or equal to 32)

[0738] dq0=(dq0+Abs(q5,0-2*q 4,0 +q 3,0 )+1)>>1

[0739] dq3=(dq3+Abs(q5,3-2*q 4,3 + q3，3 )+1)>>1

[0740] Then, as in ITU-T H.265, dpq0, dpq3, dp, dq, and d are derived.

[0741] As in ITU-T H.265, when d is less than β, the following ordered steps are applied:

[0742] As in ITU-T H.265, dpq is derived.

[0743] sp3 = Abs(p3-p0), derived as in ITU-T H.265.

[0744] If (p side is greater than or equal to 32 && LongTapDeblocking && ControlSamplesAccessible)

[0745] sp3=(sp3+Abs(p7-p3)+1)>>1

[0746] sq3 = Abs(q0-q3), derived as in ITU-TH.265.

[0747] If (q side is greater than or equal to 32 && LongTapDeblocking)

[0748] sq3=(sq3+Abs(q7-q3)+1)>>1

[0749] As derived in ITU-T H.265, StrongFilterCondition = (dpq < (β >> 2), sp3 + sq3 < (LongTapDeblocking) ? (3 * β >> 5) : (β >> 3)), and Abs(p0 - q0) < (5 * t C +1)>>1)? TRUE: FALSE

[0750] When StrongFilterCondition and LongTapDeblocking are both TRUE, a brighter filter is used on the side with a length greater than or equal to 32 perpendicular to the boundary edge.

[0751] Otherwise, when StrongFilterCondition is TRUE and LongTapDeblocking is FALSE, another strong filter (e.g., HEVC strong filter HEVC P, HEVC Q) is used.

[0752] In one example, the threshold used for comparison could also be based on location. For instance, whether the edge being unblocked is aligned with the CTU boundary.

[0753] In one example, a 4×4 brightness unblocking mesh may require one of the following:

[0754] When the block width / height is equal to 4 for the vertical edge / horizontal edge respectively, and if the HEVC filter on / off conditions (i.e., d < β, where d = d0 + d3 and d0 = dp0 + dq0 and d3 = dp3 + dq3) are evaluated as true for the corresponding edge, the method will enforce a normal / weak HEVC filter with at most one sample modification. Therefore, the following HEVC condition [δ] < 10(t) is checked. C ), where δ=(9*(q0-p0)-(3*(q1-p1)+8>>4, and if the condition is evaluated as true, then the samples p0 and q0 are modified. Otherwise, no filtering is applied.

[0755] When the block width / height is equal to 4 for both the vertical and horizontal edges, a maximum of three samples are used in the filter decision, and the filter modifies only one sample. Used to replace the condition check of strong / weak filters Furthermore, only the strong filter and the weak filter are allowed to modify p0 and q0.

[0756] In one example, according to the technique described herein, chroma can be deblocked based on a 2×2 chroma sample grid (or, in some examples, a 4×4 luminance sample grid). In this example, the HEVC_P P-side filter and HEVC_QQ-side filter described above can be used. Furthermore, when p0 belongs to a CTU higher than the current CTU, a weak chroma filter described above as NW00P can be used. In one example, a strong filter can be used when the HEVC luminance strong filter condition calculated for chroma is true and any of the following conditions are true:

[0757] - The edge type is vertical, and p0 belongs to a CU (chroma sample) with a width >= 16, and q0 belongs to a CU (chroma sample) with a width >= 16.

[0758] - The edge type is horizontal, and p0 belongs to the CU (chroma sample) with height >= 16, q0 belongs to the CU (chroma sample) with height >= 16.

[0759] See you again Figure 8 The entropy coding unit 218 receives quantized transform coefficients and prediction syntax data (i.e., intra-frame prediction data and motion prediction data). It should be noted that in some examples, the coefficient quantization unit 206 may perform a scan of the matrix including the quantized transform coefficients before outputting the coefficients to the entropy coding unit 218. In other examples, the entropy coding unit 218 may perform a scan. The entropy coding unit 218 may be configured to perform entropy coding according to one or more of the techniques described herein. Thus, the video encoder 200 represents an example of a device configured to receive an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and to modify the sample values ​​in the adjacent reconstructed video blocks according to multiple pass domains of the deblocking filter.

[0760] See you again Figure 7 The data encapsulator 107 can receive encoded video data and generate a compatible bitstream according to a defined data structure, such as a NAL unit sequence. A device receiving the compatible bitstream can reproduce the video data from it. Furthermore, the device receiving the compatible bitstream can perform a sub-bitstream extraction process, where sub-bitstream extraction refers to the process by which the device receiving the compatible bitstream forms a new compatible bitstream by discarding and / or modifying data in the received bitstream. It should be noted that the term "compliant bitstream" can be used instead of "compatible bitstream".

[0761] See you again Figure 7Interface 108 may include any device configured to receive data generated by data encapsulator 107 and to transfer and / or store data to a communication medium. Interface 108 may include a network interface card such as an Ethernet card, and may include an optical transceiver, an RF transceiver, or any other type of device capable of transmitting and / or receiving information. Furthermore, interface 108 may include a computer system interface that enables files to be stored on a storage device. For example, interface 108 may include chipsets supporting Peripheral Component Interconnect (PCI) and Peripheral Component Fast Interconnect (PCIe) bus protocols, proprietary bus protocols, Universal Serial Bus (USB) protocols, FC, or any other logical and physical architecture that can be used to interconnect peer devices.

[0762] See you again Figure 7 The target device 120 includes an interface 122, a data decapsulator 123, a video decoder 124, and a display 126. Interface 122 may include any device configured to receive data from a communication medium. Interface 122 may include a network interface card such as an Ethernet card, and may include an optical transceiver, an RF transceiver, or any other type of device capable of receiving and / or transmitting information. Furthermore, interface 122 may include a computer system interface that allows retrieval of compatible video bitstreams from a storage device. For example, interface 122 may include a chipset supporting PCI and PCIe bus protocols, dedicated bus protocols, USB protocols, FC protocols, or any other logical and physical structure that can be used to interconnect peer devices. Data decapsulator 123 may be configured to receive and parse any of the exemplary parameter sets described herein.

[0763] Video decoder 124 may include any device configured to receive bitstreams and / or their acceptable variants, and to reproduce video data therefrom. Display 126 may include any device configured to display video data. Display 126 may include one of a variety of display devices such as a liquid crystal display (LCD), a plasma display, an organic light-emitting diode (OLED) display, or another type of display. Display 126 may include a high-definition display or an ultra-high-definition display. It should be noted that, although in Figure 7 In the example shown, video decoder 124 is described as outputting data to display 126, but video decoder 124 can be configured to output video data to various types of devices and / or their sub-components. For example, video decoder 124 can be configured to output video data to any communication medium, as described herein.

[0764] Figure 9 This is a block diagram illustrating an example of a video decoder that can be configured to decode video data according to one or more techniques of this disclosure.

[0765] In one example, the video decoder 300 can be configured to decode transform data and reconstruct residual data from transform coefficients based on the decoded transform data. The video decoder 300 can be configured to perform intra-frame prediction decoding and inter-frame prediction decoding, and therefore can be referred to as a hybrid decoder. Figure 9 In the example shown, the video decoder 300 includes an entropy decoding unit 302, an inverse quantization unit 304, an inverse transform coefficient processing unit 306, an intra-frame prediction processing unit 308, an inter-frame prediction processing unit 310, a summer 312, a filter unit 314, and a reference buffer 316. The video decoder 300 can be configured to decode video data in a manner consistent with video coding systems. It should be noted that although the exemplary video decoder 300 shown has different functional blocks, such illustrations are intended for descriptive purposes and do not limit the video decoder 300 and / or its sub-components to a particular hardware or software architecture. The functionality of the video decoder 300 can be implemented using any combination of hardware, firmware, and / or software implementations.

[0766] like Figure 9 As shown, the entropy decoding unit 302 receives an entropy-encoded bitstream. The entropy decoding unit 302 can be configured to decode syntax elements and quantization coefficients from the bitstream according to a process that is the inverse of the entropy encoding process. The entropy decoding unit 302 can be configured to perform entropy decoding according to any of the entropy encoding techniques described above. The entropy decoding unit 302 can determine the values ​​of syntax elements in the encoded bitstream in a manner consistent with video coding standards. For example... Figure 9 As shown, the entropy decoding unit 302 can determine the quantization coefficient values ​​and prediction data from the bitstream. Figure 9 In the example shown, the inverse quantization unit 304 receives the quantization coefficient values ​​and outputs the transform coefficients. The inverse transform processing unit 306 receives the transform coefficients and outputs the reconstructed residual data.

[0767] See you again Figure 9The reconstructed residual data can be provided to the summer 312. The summer 312 can add the reconstructed residual data to the predicted video block and generate reconstructed video data. The predicted video block can be determined according to the predicted video technique (i.e., intra-frame prediction and inter-frame prediction). The intra-frame prediction processing unit 308 can be configured to receive intra-frame prediction syntax elements and retrieve the predicted video block from the reference buffer 316. The reference buffer 316 may include a memory device configured to store one or more video data frames. The intra-frame prediction syntax elements can identify intra-frame prediction modes, such as those described above. The inter-frame prediction processing unit 308 can receive inter-frame prediction syntax elements and generate motion vectors to identify the predicted block in one or more reference frames stored in the reference buffer 316. The inter-frame prediction processing unit 310 can generate motion-compensated blocks, possibly performing interpolation based on an interpolation filter. Identifiers for the interpolation filter used for motion estimation with sub-pixel precision can be included in the syntax elements. The inter-frame prediction processing unit 310 can use the interpolation filter to compute interpolated values ​​for sub-integer pixels of the reference block.

[0768] Filter unit 314 can be configured to perform filtering on the reconstructed video data. For example, filter unit 314 can be configured to perform deblocking and / or sample adaptive offset (SAO) filtering, for example, based on parameters specified in the bitstream. Furthermore, it should be noted that in some examples, filter unit 314 can be configured to perform dedicated arbitrary filtering (e.g., visual enhancement, such as mosquito noise cancellation). Filter unit 314 can operate in a similar manner to filter unit 216. Figure 9 As shown, the video decoder 300 can output reconstructed video blocks. Thus, the video decoder 300 can be configured to receive an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and to modify the sample values ​​in adjacent reconstructed video blocks according to multiple pass domains of the deblocking filter.

[0769] In one or more examples, the functionality may be implemented by hardware, software, firmware, or any combination thereof. If implemented in software, the functionality may be stored as one or more instructions or code on or transmitted over a computer-readable medium and executed by a hardware-based processing unit. A computer-readable medium may include a computer-readable storage medium corresponding to a tangible medium such as a data storage medium, or a propagation medium that includes, for example, any medium facilitating the transfer of a computer program from one place to another according to a communication protocol. Thus, a computer-readable medium may generally correspond to: (1) a non-transitory tangible computer-readable storage medium, or (2) a communication medium such as a signal or carrier wave. A data storage medium may be any available medium that can be accessed by one or more computers or one or more processors to retrieve instructions, code, and / or data structures for implementing the techniques described in this disclosure. Computer program products may include computer-readable media.

[0770] By way of example, and not limitation, such computer-readable storage media may include RAM, ROM, EEPROM, CD-ROM or other optical disc storage devices, magnetic disk storage devices or other magnetic storage devices, flash memory, or any other medium that can be used to store required program code in the form of instructions or data structures and that is accessible by a computer. Furthermore, any connection is appropriately referred to as a computer-readable medium. For example, coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium if instructions are transmitted from a website, server, or other remote source using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave. However, it should be understood that computer-readable storage media and data storage media do not include connections, carrier waves, signals, or other transient media, but rather refer to non-transient tangible storage media. As used herein, disks and optical discs include compact optical discs (CDs), laser discs, optical discs, digital versatile optical discs (DVDs), floppy disks, and Blu-ray discs, where disks typically copy data magnetically, while optical discs use lasers to copy data optically. Combinations of the above should also be included within the scope of computer-readable media.

[0771] Instructions can be executed by one or more processors, such as one or more digital signal processors (DSPs), general-purpose microprocessors, application-specific integrated circuits (ASICs), field-programmable arrays (FPGAs), or other equivalent integrated or discrete logic circuits. Therefore, the term "processor" as used herein can refer to any of the foregoing structures or any other structure suitable for implementing the techniques described herein. Furthermore, in some aspects, the functionality described herein can be provided within dedicated hardware and / or software modules configured for encoding and decoding, or incorporated into combined codecs. Moreover, these techniques can be implemented entirely within one or more circuit or logic elements.

[0772] The techniques disclosed herein can be implemented in various devices or apparatuses, including wireless mobile phones, integrated circuits (ICs), or a set of ICs (e.g., chipsets). Various components, modules, or units are described in this disclosure to emphasize functional aspects of a device configured to perform the disclosed techniques, but they do not necessarily need to be implemented through different hardware units. Rather, as described above, various units can be combined in a codec hardware unit, or provided through an interoperable hardware unit comprising a collection of one or more processors as described above, combined with suitable software and / or firmware.

[0773] Furthermore, each functional block or feature of the base station equipment and terminal equipment used in each of the above embodiments can be implemented or executed by circuitry (typically one or more integrated circuits). Circuitry designed to perform the functions described in this specification can include general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components, or combinations thereof. The general-purpose processor can be a microprocessor, or alternatively, it can be a conventional processor, controller, microcontroller, or state machine. The general-purpose processor or each of the above circuitry can be configured by digital circuitry or by analog circuitry. Furthermore, when advancements in semiconductor technology lead to the development of technologies for manufacturing integrated circuits that replace current integrated circuits, integrated circuits produced using such technologies can also be used.

[0774] Various examples have been described. These and other examples are within the scope of the following claims.

[0775] <Cross-reference>

[0776] This non-provisional application requests, pursuant to Section 119 of Title 35 of the United States Code (35 U.SC § 119), the following provisional applications filed: March 30, 2018, 62 / 651,058; April 7, 2018, 62 / 654,379; April 9, 2018, 62 / 655,029; April 11, 2018, 62 / 656,291; May 29, 2018, 62 / 677,629; and June 1, 2018, 62 / 677,629. Priority claims to 9,716, 62 / 696,309 (July 10, 2018), 62 / 711,420 (July 27, 2018), 62 / 714,755 (August 5, 2018), 62 / 732,556 (September 17, 2018), 62 / 733,067 (September 18, 2018), 62 / 735,090 (September 22, 2018), and 62 / 737,596 (September 27, 2018), the entire contents of which are incorporated herein by reference.

Claims

1. A method for filtering reconstructed video data, the method comprising: Receive sample values ​​from the first and second blocks adjacent to the horizontal block boundary in the reconstructed video data; Evaluate whether the height of the first block is greater than or equal to 32 samples; Evaluate whether the height of the second block is not greater than or equal to 32 samples; For the first block, based on the formula Calculate the first gradient value; For the second block, based on formula Calculate the second gradient value; as well as Based on whether the variable calculated using the sum of the first gradient value and the second gradient value is less than a threshold, it is determined whether to filter the samples included in the first block and the second block according to linear interpolation. The linear interpolation uses a reference intermediate value calculated based on the following formula: ， Where abs(x) returns the absolute value of x. Where p0 is the value of the first sample in the first block that is directly adjacent to the boundary of the horizontal block. Where p1 is the value of the second sample in the first block that is adjacent to the first sample and located one position away from the boundary of the horizontal block. Where p2 is the value of the third sample in the first block that is adjacent to the second sample and located one position away from the boundary of the horizontal block. Where p3 is the value of the fourth sample in the first block, which is adjacent to the third sample and located one position away from the boundary of the horizontal block. Where p4 is the value of the fifth sample in the first block, which is adjacent to the fourth sample and located one position away from the boundary of the horizontal block. Where p5 is the value of the sixth sample in the first block, which is adjacent to the fifth sample and located one position away from the boundary of the horizontal block. Where p6 is the value of the seventh sample in the first block, which is adjacent to the sixth sample and located one position away from the boundary of the horizontal block. Where q0 is the value of the eighth sample in the second block that is directly adjacent to the boundary of the horizontal block. Where q1 is the value of the ninth sample in the second block, which is adjacent to the eighth sample and located one position away from the boundary of the horizontal block, and Where q2 is the value of the tenth sample in the second block that is adjacent to the ninth sample and located one position away from the boundary of the horizontal block.

2. An apparatus for filtering reconstructed video data, comprising: processor; as well as A memory storing instructions that, when executed by the processor, cause the device to perform filtering on reconstructed video data, the device being configured to: Receive sample values ​​from the first and second blocks adjacent to the horizontal block boundary in the reconstructed video data; Evaluate whether the height of the first block is greater than or equal to 32 samples; Evaluate whether the height of the second block is not greater than or equal to 32 samples; For the first block, based on the formula Calculate the first gradient value; For the second block, based on formula Calculate the second gradient value; as well as Based on whether the variable calculated using the sum of the first gradient value and the second gradient value is less than a threshold, it is determined whether to filter the samples included in the first block and the second block according to linear interpolation. The linear interpolation uses a reference intermediate value calculated based on the following formula: ， Where abs(x) returns the absolute value of x. Where p0 is the value of the first sample in the first block that is directly adjacent to the boundary of the horizontal block. Where p1 is the value of the second sample in the first block that is adjacent to the first sample and located one position away from the boundary of the horizontal block. Where p2 is the value of the third sample in the first block that is adjacent to the second sample and located one position away from the boundary of the horizontal block. Where p3 is the value of the fourth sample in the first block, which is adjacent to the third sample and located one position away from the boundary of the horizontal block. Where p4 is the value of the fifth sample in the first block, which is adjacent to the fourth sample and located one position away from the boundary of the horizontal block. Where p5 is the value of the sixth sample in the first block, which is adjacent to the fifth sample and located one position away from the boundary of the horizontal block. Where p6 is the value of the seventh sample in the first block, which is adjacent to the sixth sample and located one position away from the boundary of the horizontal block. Where q0 is the value of the eighth sample in the second block that is directly adjacent to the boundary of the horizontal block. Where q1 is the value of the ninth sample in the second block, which is adjacent to the eighth sample and located one position away from the boundary of the horizontal block, and Where q2 is the value of the tenth sample in the second block that is adjacent to the ninth sample and located one position away from the boundary of the horizontal block.

Images