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 pass domains of a deblocking filter. The filtered pass domain may correspond to processing or construction of all or a subset of samples to be deblocked. The number of processes or constructs for each sample in a given pass domain may correspond to a pass domain index or order.

Description

[0001] This application is a divisional application of the Chinese invention patent application "System and method for applying a deblocking filter to reconstruct video data" with an application date of March 25, 2019 and application number 201980023322.9. Technical Field

[0002] The present disclosure relates to video encoding and, more particularly, to techniques for performing deblocking of reconstructed video data. Background Art

[0003] Digital video capabilities can be incorporated into various devices, including digital televisions, laptop or desktop computers, tablet computers, digital recording devices, digital media players, video game devices, cellular phones (including so-called smart phones), medical imaging devices, etc. Digital video can be encoded according to a video coding standard. Video coding standards can be combined with video compression technology. 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 High Efficiency Video Coding (HEVC) of the ITU-T H.265 Recommendation in December 2016, which is incorporated herein by reference and is referred to as ITU-TH.265 in this article. ITU-T H.265 is currently being considered for expansion and improvement to develop the next generation of 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 studying the potential need for standardization of future video coding technologies with compression capabilities significantly exceeding the current HEVC standard. The Joint Exploration Model 7 (JEM 7), Algorithmic Description of the Joint Exploration Test Model 7 (JEM 7), ISO / IEC JTC1 / SC29 / WG11 document: JVET-G1001 (July 2017, Torino, Italy), incorporated herein by reference, describes the coding features under investigation by JVET under the Joint Test Model, which is a potential enhanced video coding technology beyond 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 may refer collectively to the algorithms included in JEM 7 and to specific implementations of the JEM reference software.

[0004] Video compression techniques reduce the data requirements for storing and transmitting video data by exploiting the inherent redundancy in video sequences. Video compression techniques can subdivide video sequences into successively smaller parts (i.e., groups of frames within a video sequence, frames within a group of frames, slices within a frame, coding tree units (e.g., macroblocks) within a slice, coding blocks within a coding tree unit, etc.). Intra-frame prediction coding techniques (e.g., within a picture (space)) and inter-frame prediction techniques (i.e., between pictures (time)) can be used to generate the difference between the video data unit to be encoded and the reference unit of the video data. The difference can be referred to as residual data. The residual data can be encoded as quantized transform coefficients. Syntax elements can involve residual data and reference coding units (e.g., intra-frame prediction mode indexes, motion vectors, and block vectors). The residual data and syntax elements can be entropy encoded. Entropy-encoded 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 of filtering reconstructed video data includes receiving an array of sample values ​​comprising adjacent reconstructed video blocks for video data components, and modifying sample values ​​in the adjacent reconstructed video blocks according to a plurality of passes of a deblocking filter. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] Figure 1 is a conceptual diagram illustrating an example of a set of pictures encoded according to quadtree binary tree partitioning, where the quadtree binary tree partitioning is according to one or more techniques of this disclosure.

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

[0008] Figure 3 is a conceptual diagram illustrating a possible encoding structure for a block of video data, in accordance with one or more techniques of this disclosure.

[0009] Figure 4A is a conceptual diagram illustrating an example of encoding a block of video data in accordance with one or more techniques of this disclosure.

[0010] Figure 4B is a conceptual diagram illustrating an example of encoding a block of video data in accordance with one or more techniques of this disclosure.

[0011] Figure 5A is a conceptual diagram illustrating a block of video data including a deblocking boundary, in accordance with one or more techniques of this disclosure.

[0012] Figure 5B is a conceptual diagram illustrating a block of video data including a deblocking boundary, in accordance with one or more techniques of this disclosure.

[0013] Figure 6 is an example of a table that may be used to determine deblocking parameters in accordance with one or more techniques of this disclosure.

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

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

[0016] Fig. 9 is a block diagram illustrating an example of a video decoder that may be configured to decode video data in accordance with one or more techniques of this disclosure. Fig.10 is a flow diagram illustrating an example of performing deblocking in accordance with one or more techniques of this disclosure.

[0017] Fig.11 is a flow diagram illustrating an example of performing deblocking in accordance with one or more techniques of this disclosure.

[0018] Fig.12 is a flow diagram illustrating an example of performing deblocking in accordance with one or more techniques of this disclosure.

[0019] Fig.13 is an example of a table that may be used to determine deblocking parameters in accordance with one or more techniques of this disclosure.

[0020] Fig.14A is a conceptual diagram illustrating a block of video data including a deblocking boundary, in accordance with one or more techniques of this disclosure.

[0021] Fig. 14B is a conceptual diagram illustrating a block of video data including a deblocking boundary, in accordance with one or more techniques of this disclosure. DETAILED DESCRIPTION

[0022] In general, the present disclosure describes various techniques for encoding video data. Specifically, the present disclosure describes techniques for performing deblocking of reconstructed video data. It should be noted that although the techniques of the present disclosure are described with respect to ITU-T H.264, ITU-T H.265, and JEM, the techniques of the present disclosure can be generally applied 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, which are 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 interpreted as limiting the scope of the techniques described herein. In addition, it should be noted that the incorporation of the document by reference herein should not be interpreted as limiting or creating ambiguity with respect to the terms used herein. For example, where an incorporated reference provides a definition for a term that differs from that of another incorporated reference and / or as used herein, the term should be interpreted in a manner that broadly includes each respective definition and / or in a manner that includes each specific definition in alternatives.

[0023] In one example, an apparatus for video encoding includes one or more processors configured to receive an array of sample values ​​comprising adjacent reconstructed video blocks for a video data component and to modify the sample values ​​in the adjacent reconstructed video blocks based on a plurality of passes of a deblocking filter.

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

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

[0026] The details of one or more examples are set forth in the accompanying drawings and the description below. Other features, objects, and advantages will be apparent from the description and drawings, and from the claims.

[0027] Video content generally includes a video sequence consisting of a series 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, wherein the slices or tiles include multiple video blocks. As used herein, the term "video block" may generally refer to an area of ​​a picture, or may more specifically refer to a maximum array of sample values ​​that can be predictively encoded, its sub-partitions and / or corresponding structures. In addition, the term "current video block" may refer to an area of ​​a picture being encoded or decoded. A video block may be defined as an array of sample values ​​that can be predictively encoded. It should be noted that in some cases, a pixel value may be described as a sample value comprising a corresponding component of video data, which may also be referred to as a color component (e.g., brightness (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" may be used interchangeably. Video blocks may be sorted within a picture according to a scanning mode (e.g., raster scanning). A video encoder may perform predictive coding on a video block and its sub-partitions. A video block and its sub-partitions may be referred to as a node.

[0028] ITU-T H.264 specifies a macroblock structure including 16×16 luma samples. That is, in ITU-T H.264, a picture is segmented into macroblocks. ITU-T H.265 specifies a similar coding tree unit (CTU) structure, which may also be referred to as a maximum coding unit (LCU). In ITU-T H.265, a picture is segmented into CTUs. In ITU-T H.265, for a picture, the CTU size may be set to include 16×16, 32×32, or 64×64 luma samples. In ITU-T H.265, a CTU is composed of a corresponding coding tree block (CTB) for each component of the video data, for example, luma (Y) and chroma (Cb and Cr). In addition, in ITU-TH.265, a CTU may be partitioned according to a quadtree (QT) partitioning structure, which causes the CTB of a CTU to be partitioned into coding blocks (CBs). That is, in ITU-T H.265, a CTU can be divided into quad leaf nodes. According to ITU-T H.265, a luma CB together with two corresponding chroma CBs and associated syntax elements is called a coding unit (CU). In ITU-T H.265, the minimum allowed size of a CB can be signaled. In ITU-T H.265, the minimum allowed minimum size of a luma CB is 8×8 luma samples. In ITU-T H.265, the decision to encode a picture area using intra prediction or inter prediction is made at the CU level.

[0029] In ITU-T H.265, a CU is associated with a prediction unit (PU) structure having its root at the CU. In ITU-T H.265, the PU structure allows the partitioning of luma CB and chroma CB to generate corresponding reference samples. That is, in ITU-T H.265, the luma CB and chroma CB can be partitioned into corresponding luma and chroma prediction blocks (PBs), where the PBs include blocks of sample values ​​to which the same prediction is applied. In ITU-T H.265, the CB can be divided into 1, 2, or 4 PBs. ITU-T H.265 supports PB sizes from 64×64 samples down to 4×4 samples. In ITU-T H.265, square PBs are supported for intra prediction, where the CBs can form a PB, or the CBs can be partitioned into four square PBs (i.e., the intra 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 PBs, rectangular PBs are also supported for inter prediction, where the CB can be halved vertically or horizontally to form a PB (i.e., inter prediction PB types include M×M, M / 2×M / 2, M / 2×M, or M×M / 2). In addition, it should be noted that in ITU-T H.265, for inter prediction, four asymmetric PB partitions are supported, where the CB is divided into two PBs at one quarter of the height (top or bottom) or width (left or right) of the CB (i.e., asymmetric partitions include M / 4×M left, M / 4×M right, M×M / 4 top, and M×M / 4 bottom). Intra prediction data (e.g., intra prediction mode syntax elements) or inter 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 luma samples. JEM specifies a quadtree plus binary tree (QTBT) block structure. In JEM, the QTBT structure allows the quadtree leaf nodes to be further divided by the binary tree (BT) structure. That is, in JEM, the binary tree structure allows the quadtree leaf nodes to be recursively divided vertically or horizontally. Figure 1 An example is shown in which a CTU (e.g., a CTU having a size of 256×256 luma samples) is divided into quad leaf nodes and the quad leaf nodes are further divided according to a binary tree. That is, in Figure 1 In FIG. 1 , the dashed lines indicate additional binary tree partitions in the quadtree. Therefore, the binary tree structure in JEM implements square and rectangular leaf nodes, where each leaf node includes a CB. Figure 1 As shown, a picture included in a GOP may include slices, wherein each slice includes a CTU sequence, and each CTU may be divided according to a QTBT structure. Figure 1An example of QTBT partitioning of a CTU included in a slice is shown. Thus, the binary tree structure in JEM implements square and rectangular leaf nodes, each of which includes a CB. In JEM, CBs are 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. Thus, a JEMQTBT leaf node can be similar to a PB in ITU-T H.265.

[0031] The video sampling format (which may also be referred to as the chroma format) may define the number of chroma samples included in a CU relative to the number of luma samples included in the CU. For example, for a 4:2:0 sampling format, the sampling rate of the luma 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 array for the luma component are twice the width and height of each sample array for the chroma components. Figure 2 is a conceptual diagram illustrating an example of coding units formatted according to a 4:2:0 sample format. Figure 2 shows the relative position of chroma samples relative to luma samples within a CU. As mentioned above, a CU is usually defined based on the number of horizontal and vertical luma samples. Figure 2 As shown, a 16×16 CU formatted according to the 4:2:0 sample format includes 16×16 samples for the luma component and 8×8 samples for each chroma component. Figure 2 In the example shown, the relative positions of chroma samples of adjacent video blocks of a 16×16 CU with respect to luma samples are shown. For a CU formatted according to the 4:2:2 format, the width of the sample array of the luma component is twice the width of the sample array of each chroma component, but the height of the sample array of the luma component is equal to the height of the sample array of each chroma component. In addition, for a CU formatted according to the 4:4:4 format, the sample array of the luma component has the same width and height as the sample array of each chroma component.

[0032] As described above, intra prediction data or inter prediction data is used to generate reference sample values ​​for a block of sample values. The difference between the 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) may be referred to as residual data. The residual data may include a corresponding difference array corresponding to each component of the video data. The residual data may be in the pixel domain. A transform such as a discrete cosine transform (DCT), a discrete sine transform (DST), an integer transform, a wavelet transform, or a conceptually similar transform may be applied to the difference array 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, in order to generate transform coefficients, the array of difference values ​​may be subdivided (e.g., four 8×8 transforms may be applied to a 16×16 residual value array). For each component of the video data, such subdivision of the difference values ​​may be referred to as a transform block (TB). It should be noted that in ITU-T H.265, TBs are not necessarily aligned with PBs. Figure 3 Examples of alternative PB and TB combinations that can be used to encode specific CBs are shown. In addition, it should be noted that in ITU-T H.265, TBs 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 PBs and TBs in ITU-T H.265. It should be noted that in JEM, a core transform and a subsequent secondary transform can be applied (in a video encoder) to generate transform coefficients. For a video decoder, the order of transforms is reversed. In addition, in JEM, whether a secondary transform is applied to generate transform coefficients may depend on the prediction mode.

[0033] Transform coefficients may be quantized according to a quantization process. Quantization approximates transform coefficients by limiting the amplitude to a set of specified values. Quantization may be used to change the amount of data required to represent a set of transform coefficients. Quantization may 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). Thus, inverse quantization (or "dequantization") may include multiplying the coefficient level values ​​by the scaling factor. It should be noted that, as used herein, the term quantization process may generally refer to dividing by a scaling factor in some cases to generate level values, or may refer to multiplying by a scaling factor in some cases to restore the transform coefficients. That is, the quantization process may refer to quantization in some cases, and inverse quantization in some cases. The current video data block is reconstructed by performing inverse quantization on the level values, performing an inverse transform, and adding a set of predicted values ​​to the resulting residual. The sample values ​​of the reconstructed block may be different from the sample values ​​of the current video block input into the encoding process. In this way, encoding may be considered lossy. However, it should be noted that the difference in sample values ​​may be considered acceptable to an observer of the reconstructed video.

[0034] The quantized transform coefficients (which may be referred to as level values) may be entropy encoded according to an entropy coding technique (e.g., content adaptive variable length coding (CAVLC), context adaptive binary arithmetic coding (CABAC), probability interval partitioning entropy coding (PIPE), etc.). In addition, syntax elements (such as syntax elements indicating a prediction mode) may also be entropy encoded. The entropy encoded quantized transform coefficients and the corresponding entropy encoded syntax elements may form a compatible bitstream that may be used to reproduce video data. As part of the entropy encoding process, binarization may be performed on the syntax elements. Binarization refers to the process of converting syntax values ​​into a sequence of one or more bits. These bits may be referred to as "bins". FIG. 4A to FIG. 4B is a conceptual diagram showing an example of encoding a video data block. Figure 4A As shown, a current block of video data (e.g., corresponding to a CB of a video component) is encoded by subtracting a set of prediction values ​​from the current block of video data to generate a residual, performing a transform on the residual, and quantizing the transform coefficients to generate a level value. Figure 4B As shown, the current video data block is decoded by performing inverse quantization on the level value, performing inverse transformation, and adding a set of prediction values ​​to the resulting residual. It should be noted that in FIG. 4A to FIG. 4B In the example of , the sample values ​​of the reconstructed block are different from the sample values ​​of the current video block being encoded. In this way, the encoding can be considered lossy. However, for a viewer of the reconstructed video, the difference in sample values ​​can 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 the video block) may be entropy encoded according to an entropy coding technique. Examples of entropy coding techniques include content adaptive variable length coding (CAVLC), context adaptive binary arithmetic coding (CABAC), probability interval partitioning entropy coding (PIPE), etc. The entropy-coded quantized transform coefficients and the corresponding entropy-coded syntax elements may form a compatible bitstream that can be used to reproduce video data at a video decoder. The entropy coding process may include binarizing the syntax elements. Binarization refers to the process of converting the value of a syntax value 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 the 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 general implementations of these techniques and / or more specific implementations 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 the bin value using a lossless data compression algorithm. In the example of CAB AC, for a particular bin, a context model may be selected from a set of available context models associated with the bin. In some examples, the context model may be selected based on the value of a previous bin and / or a previous syntax element. The context model may identify the probability that a bin has a particular value. For example, the context model may indicate that the probability of encoding a box with a value of 0 is 0.7, and the probability of encoding a box with a value of 1 is 0.3. It should be noted that in some cases, the sum of the probability of encoding a box with a value of 0 and the probability of encoding a box with a value of 1 may not be equal to 1. After selecting an available context model, the CABAC entropy encoder may arithmetically encode the box based on the identified context model. The context model may be updated based on the value of the encoded box. The context model may be updated based on associated variables stored with the context, such as the adaptation window size, the number of encoded boxes using the context. It should be noted that according to ITU-T H.265, the CABAC entropy encoder may be implemented so that some syntax elements may be entropy encoded using arithmetic coding without using an explicitly specified context model, and such encoding may be referred to as bypass coding.

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

[0037] For inter-frame prediction coding, a motion vector (MV) identifies a reference sample in a picture other than the picture of the video block to be encoded, thereby exploiting 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 a motion vector can be used to indicate the location of the reference block. The motion vector and associated data may 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, half-pixel precision, one-pixel precision, two-pixel precision, four-pixel precision), the prediction direction, and / or the reference picture index value. In addition, coding standards such as ITU-T H.265 may support motion vector prediction. Motion vector prediction allows the motion vector to be specified to use the motion vectors of neighboring 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 Motion Vector Prediction (STMVP), Pattern Matching Motion Vector Derivation (PMMVD) mode, which is a special merge mode based on the Frame Rate Up-Conversion (FRUC) technology, and affine transform motion compensation prediction technology.

[0038] As described 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 degree of quantization) reduces the amount of data required to represent a set of coefficients. In ITU-T H.265, the degree of quantization can be determined by a quantization parameter QP. In ITU-T H.265, for a bit depth of 8 bits, QP can take 52 values ​​from 0 to 51, and a QP change of 1 generally corresponds to a change in the value of the quantization scaling factor of about 12%. 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 (including the end value). Therefore, for example, in the case of a bit depth of 10 bits, QP can take 64 values ​​from -12 to 51, which can be mapped to values ​​0 to 63 during dequantization. In ITU-T H.265, the quantization parameter can be updated for each CU, and a corresponding quantization parameter can be derived for each of the luminance component and the chrominance component. It should be noted that as the degree of quantization increases (eg, the transform coefficients are divided by larger scaling factor values), the amount of distortion may increase (eg, the reconstructed video data may appear more "blocky" to a user).

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

[0040] For the formulas used in this article, the following arithmetic operators can be used:

[0041] + Addition

[0042] - Subtraction

[0043] * Multiplication, including enemy array multiplication

[0044] / Integer division truncates the result towards zero. For example, 7 / 4 and -7 / -4 are truncated to 1, and -7 / 4 is truncated to -1.

[0045] The sum of f(i) takes all integer values ​​from x to y and includes y.

[0046] Additionally, the following math functions are available:

[0047]

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

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

[0050]

[0051] Additionally, the following definitions of logical operators apply:

[0052] x&&y Boolean logical "AND" of x and y

[0053] x||y Boolean logical OR of x and y

[0054] ! Boolean logic "NO"

[0055] x? y:z If x is TRUE or not equal to 0, it evaluates to y; otherwise, it evaluates to z.

[0056] Additionally, the following relational operators can be applied:

[0057] > Greater than

[0058] ≥ greater than or equal to

[0059] < Less than

[0060] ≤ Less than or equal to

[0061] == is equal to

[0062] ! = Not equal to

[0063] Additionally, the following bitwise operators apply:

[0064] x>>y Arithmetic right shift of the two's complement integer representation of the x-by-y binary number. This function is defined only for non-negative integer values ​​of y. The bits shifted into the most significant bit (MSB) as a result of the right shift have a value equal to the MSB of x before the shift operation.

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

[0066] Deblocking (or deblocking), deblocking filtering, performing deblocking or applying a deblocking filter refers to the process of smoothing the boundary of a video block and an adjacent reconstructed video block (i.e., making the boundary less noticeable to the observer). Smoothing the boundary of adjacent reconstructed video blocks may include modifying the sample values ​​included in the rows or columns adjacent to the boundary. ITU-T H.265 provides a scenario in which a deblocking filter is applied to the reconstructed sample values ​​as part of a filtering process in a loop. ITU-T H.265 includes two types of deblocking filters that can be used to modify luma samples: a strong filter that modifies the sample values ​​in three rows or columns adjacent to the boundary; a weak filter that modifies the sample values ​​in the rows or columns immediately adjacent to the boundary and conditionally modifies the sample values ​​in the second row or column starting from the boundary. In addition, ITU-T H.265 includes a type of filter that can be used to modify chroma samples, namely, a normal filter.

[0067] FIG. 5A to FIG. 5B 1 shows sample values ​​included in video blocks P and Q having boundaries. As used herein, video blocks P and Q are used to refer to adjacent video blocks having block boundaries on which deblocking can be applied. The manner in which sample values ​​are modified can be based on a defined filter, where pi and qi represent corresponding sample values ​​in columns for vertical boundaries and sample values ​​in rows for horizontal boundaries, and pi′ and qi′ represent modified sample values. The defined filter can define samples to be modified (or filtered) and samples used to determine how to modify the samples. For example, Figure 5A As shown, in one example, sample values ​​in each of the first three columns adjacent to the deblocking boundary (shown as filtered samples) may be modified based on sample values ​​included in each of the first four columns adjacent to the deblocking boundary (shown as supporting samples).

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

[0069] Strong filter

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

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

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

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

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

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

[0076] Weak filter

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

[0078] p0'=p0+Δ

[0079] q0'=q0-Δ

[0080] where p1 and q1 are conditionally modified as described below, as follows

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

[0082] Δq=((q2+p0+1) / 2-q1-Δ) / 2

[0083] p1'=p1+Δp

[0084] q1'=q1+Δq

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

[0086] Ordinary filter

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

[0088] p0'=p0+Δ

[0089] q0'=q0-Δ

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

[0091] If P and Q are two adjacent coding blocks, the filter strength Bs is specified as:

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

[0093] Otherwise, if P and Q belong to different TBs, then P or Q has at least one non-zero transform coefficient, then Bs=1;

[0094] In addition, if the reference pictures of P and Q are different, Bs=1;

[0095] In addition, if the difference between the x motion vector component or the y motion vector component of P and Q is equal to or greater than an integer sample, then Bs=1;

[0096] In addition, Bs=0.

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

[0098] For brightness:

[0099] For β':

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

[0101] For t C '

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

[0103] in,

[0104] QL =(QP Q +QP P +1) / 2;

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

[0106] slice_tc_offset_div2 is applied to include sample q 0，0 The offset value of the video data slice

[0107] For ITU-T H.265, the variables β and Q are derived as follows:

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

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

[0110] Among them, BitDepth y Specifies the bit depth of luma samples.

[0111] ITU-T H.265 defines a variable d, where d is determined based on the luma sample value as follows:

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

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

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

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

[0116] dpq0=dp0+dq0

[0117] dpq3=dp3+dq3

[0118] dp=dp0+dp3

[0119] dq=dq0+dq3

[0120] d=dpq0+dpq3

[0121] In addition, in ITU-T H.265, the variable dpq is set to a value based on the d value and the β value. Finally, in ITU-T H.265, each of Bs, tC, β, and d is used to determine which type of filter (e.g., a strong filter or a weak filter) is applied. In addition, in ITU-T H.265, for chroma components, a normal filter is applied only when Bs is equal to 2. That is, in ITU-T H.265, if one of the blocks P or Q is generated using an intra-frame prediction mode, deblocking occurs only for the chroma components.

[0122] It should be noted that it may be useful to describe the deblocking filter in general in terms of a set of filter parameters. For example, for a set of sample values ​​{a...b} included in a row or column, the corresponding deblocked sample value y[n] may be specified based on the following formula:

[0123]

[0124] in,

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

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

[0127] x[n+m] provides the input sample values ​​corresponding to the support samples, and it should be noted that the support size may be greater than or equal to the filter length.

[0128] In addition, in ITU-T H.265, the deblocking filter can be applied differently to CTU boundaries that coincide with slice boundaries and tile boundaries than to CTU boundaries that do not coincide with slice boundaries and tile boundaries. Specifically, ITU-T H.265 specifies a flag slice_loop_filter_across_slices_enabled_flag present in the slice segment header that enables / disables the deblocking filter across CTU boundaries that coincide with the top slice boundary and the left slice boundary. ITU-T H.265 provides the following definition of slice_loop_filter_across_slices_enabled_flag:

[0129] slice_loop_filter_across_slices_enabled_flag equal to 1 specifies that in-loop filtering operations may 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 filtering operations are not performed across the left and top boundaries of the current slice. In-loop filtering operations include deblocking 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.

[0130] Wherein 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:

[0131] pps_loop_filter_across_slices_enabled_flag equal to 1 specifies that in-loop filtering operations may be performed across the left and top boundaries of slices that reference the PPS. pps_loop_filter_across_slices_enabled_flag equal to 0 specifies that in-loop filtering operations are not performed across the left and top boundaries of slices that reference the PPS. In-loop filtering operations include deblocking filtering and sample adaptive offset filtering operations.

[0132] NOTE - Loop filtering across slice boundaries can be enabled while loop filtering across tile boundaries is disabled, and vice versa.

[0133] Similarly, the flag loop_filter_across_tiles_enabled_flag present in the PPS enables / disables the deblocking filter across CTU boundaries that coincide 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 specifies that loop filtering operations can be performed across tile boundaries in pictures that reference the PPS. loop_filter_across_files_enabled_flag equal to 0 specifies that loop filtering operations are not performed across tile boundaries in pictures that reference the PPS. Loop filtering operations include deblocking filtering and sample adaptive offset filtering operations. When not present, the value of loop_filter_across_tiles_enabled_flag is inferred to be equal to 1.

[0134] As described above, for deblocking, 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 may be included in the slice segment header and have the following definition:

[0135] slice_beta_offset_div2 and slice_tc_offset_div2 specify the β and t of the current slice C The deblocking parameter offset (divided by 2) 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.

[0136] Among them, 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:

[0137] pps_beta_offset_div2 and pps_tc_offset_div2 specify the beta and t offsets applied to the slices of the reference PPS.C The default deblocking parameter offset (divided by 2) for the slice header of the referenced PPS shall be used unless the default deblocking parameter offset is overridden by a deblocking parameter offset present in the slice header of the slice that references the PPS. The values ​​of pps_beta_offset_div2 and pps_tc_offset_div2 shall both be in the range of -6 to 6 (inclusive). When not present, the values ​​of pps_beta_offset_div2 and pps_tc_offset_div2 are inferred to be equal to 0.

[0138] As mentioned above, ITU-T H.265 provides a deblocking granularity of 8×8. In JEM, deblocking is performed according to a grid specified by a variable minCUWidth for horizontal boundaries or a variable minCUHeight for vertical boundaries, where the default values ​​of minCUWidth and minCUHeight are 4. The value of d is also determined in JEM, where the calculation of d is the same as that in ITU-T H.265. Based on the above value of d, it is determined whether to perform deblocking on the boundary. That is, if d<β, the deblocking filter is used for the current boundary, otherwise, deblocking is not performed on the boundary. In addition, the decision whether to use a strong filter or a weak filter in JEM is the same as that in ITU-T H.265. Finally, in the JEM reference software, the luminance filter coefficients of the strong deblocking filter are the same as those used in ITU-T H.265. Deblocking as performed in ITU-T H.265 and JEM may not be ideal. In particular, deblocking, as performed in ITU-T H.265 and JEM, fails to take into account various encoding parameters and properties of the reconstructed video data when performing deblocking.

[0139] Figure 7 1 is a block diagram illustrating an example of a system that may be configured to encode (e.g., encode and / or decode) video data in accordance with one or more techniques of this disclosure. System 100 represents an example of a system that may encapsulate video data in accordance with 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 the encoded video data via communication medium 110 and decode the encoded video data. 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, laptop or tablet computers, game consoles, medical imaging devices, and mobile devices (including, for example, smart phones, cellular phones, personal gaming devices).

[0140] The communication medium 110 may include any combination of wireless and wired communication media and / or storage devices. The communication medium 110 may include coaxial cables, fiber optic cables, twisted pair cables, 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. The communication medium 110 may include one or more networks. For example, the 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 telecommunication protocols. The telecommunication protocol may include proprietary aspects and / or may include standardized telecommunication protocols. Examples of standardized telecommunication protocols include digital video broadcasting (DVB) standards, advanced television system committee (ATSC) standards, integrated service digital broadcasting (ISDB) standards, cable data service interface specifications (DOCSIS) standards, global mobile communication systems (GSM) standards, code division multiple access (CDMA) standards, 3rd generation partnership project (3GPP) standards, European Telecommunications Standards Institute (ETSI) standards, Internet Protocol (IP) standards, wireless application protocol (WAP) standards, and Institute of Electrical and Electronics Engineers (IEEE) standards.

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

[0142] Reference again Figure 7 , source device 102 includes video source 104, video encoder 106, data encapsulator 107 and 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 operably 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 may refer to a bitstream from which a video decoder can receive and reproduce video data. Various 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. The compression may be lossy (perceptible or imperceptible to the observer) or lossless.

[0143] Figure 8 is a block diagram illustrating an example of a video encoder 200 that may implement the techniques described herein for encoding video data. It should be noted that although the exemplary video encoder 200 is illustrated as having different functional blocks, such illustration is intended for descriptive purposes and does not limit the video encoder 200 and / or its subcomponents to a particular hardware or software architecture. The functionality of the video encoder 200 may 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 in accordance with the techniques described herein. The video encoder 200 may perform intra-frame prediction encoding and inter-frame prediction encoding of picture regions, and therefore may be referred to as a hybrid video encoder. In Figure 8In the example shown, the video encoder 200 receives a source video block. In some examples, the source video block may include a picture area that has been divided according to a coding structure. For example, the source video data may include macroblocks, CTUs, CBs, sub-partitions thereof, 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 encoding regardless of how the source video data is divided before and / or during encoding. Fig. 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, video encoder 200 receives source video blocks and outputs a bitstream.

[0144] exist Figure 8 In the example shown, the video encoder 200 can generate residual data by subtracting the predicted video block from the source video block. Summer 202 represents a component configured to perform the subtraction operation. In one example, the subtracted video block occurs in the pixel domain. Transform coefficient generator 204 applies a transform, such as a discrete cosine transform (DCT), a discrete sine transform (DST), or a conceptually similar transform, to its residual block or sub-partition (for example, 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 triangular transform series. Transform coefficient generator 204 can output the transform coefficients to coefficient quantization unit 206.

[0145] The coefficient quantization unit 206 may be configured to perform quantization of the transform coefficients. As described above, the degree of quantization may be modified by adjusting the quantization scaling factor, wherein the quantization scaling factor may be determined by a quantization parameter. The coefficient quantization unit 206 may be further configured to determine a quantization value and output QP data, which may be used by a video decoder to reconstruct a quantization parameter to perform inverse quantization during video decoding. For example, the signaled QP data may include a QP delta value. In ITU-TH.265, the degree of quantization applied to a transform coefficient set may depend on: a slice-level parameter, a parameter inherited from a previous coding unit, and / or an optionally signaled CU-level delta value.

[0146] 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 may be configured to apply inverse quantization and / or inverse transformation to generate reconstructed residual data. Figure 8 As shown, at summer 210, the reconstructed residual data can be added to the predicted video block. In this way, the encoded video block can be reconstructed, and the resulting reconstructed video block can be used to evaluate the encoding quality of a given prediction, transform type and / or quantization level. Video encoder 200 can be configured to perform multiple encoding rounds (e.g., encoding is performed while changing one or more encoding parameters). The rate distortion or other system parameters of the bitstream can be optimized based on the evaluation of the reconstructed video block. In addition, the reconstructed video block can be stored and used as a reference for predicting subsequent blocks.

[0147] As described above, intra-frame prediction may be used to encode a video block. The intra-frame prediction processing unit 212 may be configured to select an intra-frame prediction mode for a video block to be encoded. The intra-frame prediction processing unit 212 may be configured to evaluate a frame and / or a region thereof and determine an intra-frame prediction mode to be used to encode a current block. Figure 8 As shown, intra-prediction processing unit 212 outputs intra-prediction data (eg, syntax elements) to filter unit 216 and entropy encoding unit 218 .

[0148] The inter-frame prediction processing unit 214 may be configured to perform inter-frame prediction coding for the current video block. The inter-frame prediction processing unit 214 may be configured to receive a source video block and calculate a motion vector of a PU of the video block, etc. The motion vector may indicate the displacement of a PU of a video block in the current video frame, etc. relative to a prediction block in a reference frame. Inter-frame prediction coding may use one or more reference pictures. In addition, motion prediction may be unidirectional prediction (using one motion vector) or bidirectional prediction (using two motion vectors). The inter-frame prediction processing unit 214 may be configured to select a prediction block by calculating a pixel difference determined by, for example, the sum of absolute differences (SAD), the sum of square differences (SSD), or other difference metrics. The motion vector and related data may 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. In addition, coding standards such as ITU-T H.265 may support motion vector prediction. Motion vector prediction allows the motion vector to be specified to use the motion vector of a neighboring block. Examples of motion vector prediction include advanced motion vector prediction (AMVP), temporal motion vector prediction (TMVP), so-called "merge" mode, and "skip" and "direct" motion inference. The inter-prediction processing unit 214 may be configured to perform motion vector prediction according to one or more of the techniques described above. The inter-prediction processing unit 214 may be configured to generate a prediction block using motion prediction data. For example, the inter-prediction processing unit 214 may locate a prediction video block within a frame buffer ( Figure 8 ). Note that the inter-frame prediction processing unit 214 may be further configured to apply one or more interpolation filters to the reconstructed residual block to calculate sub-integer pixel values ​​for motion estimation. The inter-frame prediction processing unit 214 may output the motion prediction data of the calculated motion vector to the filter unit 216 and the entropy coding unit 218.

[0149] As mentioned above, deblocking refers to the process of smoothing the boundaries of reconstructed video blocks. Figure 8 As shown, filter unit 216 receives the reconstructed video blocks and encoding parameters (e.g., intra-frame prediction data, inter-frame prediction data, and QP data), and outputs modified reconstructed video data. Filter unit 216 may 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 reconstruction by adding an offset to the reconstructed video data. It should be noted that, as Figure 8As shown, the intra-prediction processing unit 212 and the inter-prediction processing unit 214 can receive the modified reconstructed video blocks via the filter unit 216. That is, in some cases, deblocking can occur in a loop, that is, the predicted video blocks stored in the reference buffer can be filtered. In some cases, deblocking can occur after the loop, that is, for example, after reconstructing the video data and before outputting it to a display. The techniques described herein can be applied to deblocking in the loop, deblocking after the loop, and / or a combination of both.

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

[0151] The samples on each side of the block boundary (perpendicular to the boundary edge) can be expressed as:

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

[0153] in,

[0154] |Indicates a block boundary edge.

[0155] Sample p x (where x is a positive integer starting from 0) represents the P side of the boundary. Sample q y (where y is a positive integer starting from 0) represents the Q side of the boundary.

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

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

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

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

[0160] refer to Figure 5A , when deblocking vertical edges, sample p y＞x and q y＞x Corresponding to line R[x].

[0161] refer to Figure 5B , when deblocking horizontal edges, sample p y＞x and q y＞x Corresponding to line R[y].

[0162] An example of a wider (i.e., more samples to deblock), stronger filter on the P side of the boundary (called a WS00P P-side filter) is:

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

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

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

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

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

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

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

[0170] Among them, p x ′ indicates that the x The sample value after deblocking at the position

[0171] An example of a wider (i.e., more samples to deblock), stronger filter on the Q-side of the boundary (referred to as a WS00Q Q-side filter) is:

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

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

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

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

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

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

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

[0179] Among them, q x 'Indicates that in the corresponding q x The sample value after deblocking at the position

[0180] An example of a narrow (i.e., fewer samples to deblock), strong filter on the P side of the boundary (called HEVC_PP side filter) is:

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

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

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

[0184] Among them, p x ′ indicates that the x The sample value after deblocking at the position

[0185] An example of a narrow (i.e., fewer samples to deblock), strong filter on the Q-side of the boundary (referred to as HEVC_Q Q-side filter) is:

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

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

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

[0189] Among them, q x 'Indicates that in the corresponding q x The sample value after deblocking at the position

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

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

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

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

[0194] Among them, p x ′ indicates that the x The sample value after deblocking at the position

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

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

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

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

[0199] Among them, q x 'Indicates that in the corresponding q x The sample value after deblocking at the position

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

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

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

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

[0204] An example of a narrow (fewer samples to deblock), strong filter on the Q side of the boundary (called the NS00QQ side filter) is:

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

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

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

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

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

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

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

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

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

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

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

[0216] An example of a narrow (fewer samples to deblock), weak filter on the P side of the boundary (called NW00PP side filter) is:

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

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

[0219] Among them, px ′ indicates that the x The sample value after deblocking at the position

[0220] An example of a narrow (fewer samples to deblock), weak filter on the Q-side of the boundary (called a NW00Q Q-side filter) is:

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

[0222] q0′=Clip1 C (q0-Δ)

[0223] Among them, q x 'Indicates that in the corresponding q x The sample value after deblocking at the position

[0224] An example of a filter on the P side of a boundary (referred to as a F0P P side filter) is:

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

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

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

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

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

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

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

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

[0233] An example of a filter on the Q side of the boundary (referred to as a F0Q Q side filter) is:

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

[0235] q1'=(105*p 10 +151*q6+128)>>8

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

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

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

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

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

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

[0242] An example of a filter on the P side of a boundary (referred to as an F1P P-side filter) is:

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

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

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

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

[0247] An example of a filter on the Q side of the boundary (referred to as an F1Q Q-side filter) is:

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

[0249] q1′=(2*q2+4*q1+q0+p Q +4)>>3

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

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

[0252] In one example, the distance of the sample being deblocked from the boundary may be inversely proportional to the distance between the supporting sample assigned the largest tap value and the sample being deblocked. In addition, the distance of the second largest tap value from the sample being deblocked may 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:

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

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

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

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

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

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

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

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

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

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

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

[0264] q2'=(90*p 11 +8*q2+166*q5+256)>>9

[0265] q3'=(75*p 12 +16*q3+181*q4+256)>>9

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

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

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

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

[0270] An example of a filter on the P side of a boundary (referred to as an F4P P-side filter) is:

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

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

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

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

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

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

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

[0278] An example of a filter on the Q side of the boundary (referred to as an F4Q Q-side filter) is:

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

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

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

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

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

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

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

[0286] In one example, according to the techniques herein, gradient calculations can be used to select filter parameters, the number of samples to be deblocked on one side (or both sides) of a block boundary. The gradient can be calculated using samples in line R[x].

[0287] In one example, multiple gradients may be calculated using samples in line R[x] and used for selection of filter parameters, number of samples to be deblocked on one side (or both sides) of a block boundary. In another example, multiple gradients may be calculated using samples in line R[x], and operations such as average, maximum, minimum gradients of the gradients may be used for selection of filter parameters, number of samples to be deblocked on one side (or both sides) of a block boundary.

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

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

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

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

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

[0293] Max(Max(Max(Max(Max(abs(p2-2*p1+p0)),

[0294] abs(p3-2*p2+p1)),

[0295] abs(p4-2*p3+p2)),

[0296] abs(p5-2*p4+p3)),

[0297] abs(p6-2*p5+p4)),

[0298] abs(p7-2*p6+p5))

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

[0300] Max(Max(Max(Max(Max(abs(q2-2*q1+q0)),

[0301] abs(q3-2*q2+q1)),

[0302] abs(q4-2*q3+q2)),

[0303] abs(q5-2*q4+q3)),

[0304] abs(q6-2*q5+q4)),

[0305] abs(q7-2*q6+q5))

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

[0307] (abs(p2-2*p1+p0)+abs(p a -2*p2+p1)+ab8(p5-2*p4+p a )+abs(p7-2*p6+p5)+4)>>2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0327] Similarly, a subset of the second order differences computed at q1, q2, ..., q6 may be used to compute xCalDQqLargeBlock(R[x]). In one example, the rounding offsets in the function calls xCalDQpLargeBlock(R[x]) and xCalDQqLargeBlock(R[x]) may be discarded.

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

[0329] ((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 is the threshold value.

[0330] In one example, the function call xUseStrongFilteringLargeBlock(R[x], d, bSidePisLargeBlk, bSideQisLargeBlk) computes the Boolean variable as follows:

[0331]

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

[0333]

[0334] In one example, the function call xUseStrongFilteringLargeBlock(R[x], d, bSidePisLargeBlk, bSideQisLargeBlk) computes the Boolean variable as follows:

[0335]

[0336] In one example, the rounded offset in the function call xUseStrongFilteringLargeBlock may be discarded.

[0337] In one example, the condition for selecting the number of samples to be deblocked on one side (or both sides) of the boundary corresponds to a dimension (of the current and / or neighboring blocks) perpendicular to the block boundary exceeding a threshold. In some cases, when a subset of transform coefficients for a block is set to zero based on the block size, the threshold used in the comparison may be based on a property of a subset of zero coefficients. For example, when 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 indexes start at 0), the dimension perpendicular to the block boundary is compared to a threshold of 32.

[0338] In one example, a signal may be received in the bitstream indicating whether all transform coefficients are zero for a block of samples. For example, such a signal may be received for each color component, for a group of color components, for some spatial partitioning of samples, for some spatial-temporal partitioning of samples. In HEVC, for each color component, a coded block flag (CBF) - cbf_luma, cbf_cb, cbf_cr is signaled (explicitly or implicitly by using an inference rule in the absence of an explicit signal); in addition, a flag is also signaled (explicitly or implicitly) indicating whether any color component in the transform tree contains non-zero transform coefficients and is called the residual quadtree root CBF - rqt_root_cbf.

[0339] In one example, the number of samples to be deblocked on one side (or both sides) of the boundary may be based on the type of edge being deblocked (e.g., vertical block edge, horizontal block edge), the channel type (e.g., luma, chroma), whether all transform coefficients are zero for the sample blocks on one side (or both sides) of the boundary, whether the sample blocks on one side (or both sides) of the boundary utilize a coding mode that may be based on a linear model for illumination variations, such as local illumination compensation (LIC), whether the sample blocks on one side (or both sides) of the boundary utilize cross-component prediction (which may be based on a linear model), whether the sample blocks on one side (or both sides) of the boundary utilize prediction determined for blocks smaller than the transform, whether the sample blocks on one side (or both sides) of the boundary utilize a technique in which a large block (e.g., a CU) is divided into sub-blocks (e.g., sub-CUs) and motion information is derived for these sub-blocks.

[0340] In one example, according to the techniques herein, when the size of the current block perpendicular to the block boundary is greater than or equal to a threshold value (e.g., 32), a larger number of samples (e.g., 7) are deblocked 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 value (e.g., 32), a smaller number of samples (e.g., 3) are deblocked 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 deblocked on each side of the block boundary.

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

[0342] In one example, filter unit 216 may be configured to select filter parameters (including, e.g., the number of coefficients) for deblocking according to techniques herein based on one or more of: the distance of samples being deblocked from the boundary (in number of samples), the block size on each side of the boundary, the boundary strength, the prediction mode used by blocks on each side of the boundary, the prediction mode of the samples being deblocked (e.g., using a weaker filter for boundaries close to reference samples), the QP of the samples being deblocked (e.g., using a stronger filter for larger QPs), the block size corresponding to the samples being deblocked (e.g., using a stronger filter for larger block sizes), the block size corresponding to the samples being used for deblocking, the motion vectors 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 vectors for the samples being deblocked; the motion vectors for the samples being used for deblocking. It should be noted that the block size corresponding to the 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.

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

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

[0345] In one example, selecting filter parameters may include selecting wider and stronger filtering.

[0346] In one example, according to the techniques 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 value (e.g., 32). 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)), then wider and stronger filtering is selected for each side of the block boundary.

[0347] In one example, according to the techniques of this document, filter unit 216 may be configured to select filter parameters for each side of a block boundary independently for the corresponding side 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 value (e.g., 32), a set of deblocking filter parameters (e.g., wider and stronger filtering) may be selected for the side. For example: if ((the width of a block is >= 32 and the edge type is vertical) or (the height of a block is >= 32 and the edge type is horizontal)), then a wider and stronger filtering is selected for the side of the block boundary corresponding to the block.

[0348] In one example, according to the techniques of this document, a sub-CU boundary may be deblocked based on whether all transform coefficients of a block (e.g., a CU) on one side (or both sides) of the boundary are zero. For example, when all transform coefficients of the CU are zero, the sub-CU boundary is deblocked.

[0349] In one example, according to the techniques herein, a subblock boundary may be resolved based on whether all transform coefficients of blocks on one side (or both sides) of the boundary are zero. For example, when all transform coefficients of the block are zero, the subblock boundary is resolved.

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

[0351] In one example, according to the techniques herein, a sub-block boundary may be deblocked based on whether all transform coefficients of blocks on one side (or both sides) 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, when all transform coefficients of the block are zero and the QP is greater than a threshold, the sub-block boundary is deblocked.

[0352] In one example, according to the techniques herein, a block boundary may be deblocked when local illumination compensation (LIC) is used for blocks on one side (or both sides) of the boundary and all transform coefficients of the block are zero.

[0353] In one example, according to the techniques herein, when local illumination compensation (LIC) is used for a block and all transform coefficients of the block are zero, all four boundary (ie, left, right, top, bottom) block boundaries of the block may be deblocked.

[0354] In one example, according to the techniques herein, a block boundary may be deblocked when local illumination compensation (LIC) is used for blocks on one side (or both sides) of the boundary and all transform coefficients of the block are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold).

[0355] In one example, according to the techniques herein, when local illumination compensation (LIC) is used for a block and all transform coefficients of the block are zero and the quantization step size is large (e.g., QP is greater than or equal to a threshold), all four boundary (i.e., left, right, top, bottom) block boundaries of the block may be deblocked.

[0356] In one example, according to the techniques herein, a block boundary may be deblocked when cross-component prediction is used for blocks on one side (or both sides) of the boundary and all transform coefficients of the block are zero.

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

[0358] In one example, according to the techniques of this document, filter unit 216 may be configured to perform deblocking according to multiple filter pass domains. In one example, the filter pass domain may correspond to the processing / construction of all / subsets of samples to be deblocked. The number of processes / constructions of each sample in a given pass domain may correspond to the pass domain index / order. The subset of samples to be deblocked may correspond to the pass domain index / order. In one example, each pass domain may correspond to the processing / construction of all samples to be completely deblocked once. In one example of this case, deblocked samples (and non-deblocked samples) from previous iterations may be used to construct deblocked samples for the current iteration. In one example of this case, deblocked samples (and non-deblocked samples) from previous iterations and current iterations may be used to construct deblocked samples. In this case, the ordering used to construct deblocked samples may 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 / inter) of the current CU and its neighboring CUs; ​​sample positions to be deblocked; whether d < β; and / or the strong or weak filter determination conditions provided in JEM as described above; the distance of the sample being deblocked from the boundary (in 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.

[0359] In one example, N-pass domain deblocking with predetermined deblocking support may be expressed as:

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

[0361] For pos = posM to posN / / samples being deblocked

[0362] temp[pos] = f_pos (sample value at iterldx in the deblocking support)

[0363] For pos=posM to posN

[0364] Update sampleValue[pos] through temp[pos]

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

[0366]

[0367] where coeff_pos[] is an array of values ​​that depend on the position pos of the sample being deblocked. It should be noted that deblocking may have been used in a previous iteration to generate each sampleValue[] being used. Additionally, deblocking support does not change from one iteration to the next.

[0368] Performing an iteration-by-iteration analysis provides:

[0369] For iterldx 0, the samples used are the non-deblocked samples, so for each pos:

[0370] temp[pos] = f_pos (sample value at pass-through 0 in deblocking support)

[0371] For iterldx 1,

[0372] temp[pos] = f_pos (sample value at pass 1 in deblocking support)

[0373] Since f_pos() is a linear transform and deblocking support does not change, the above can be rewritten as:

[0374] For iterldx 1,

[0375] temp[pos] = g_pos (sample value at pass-through 0 in deblocking support)

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

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

[0378] In one example, according to the techniques of this document, filter unit 216 can be configured to expand filter lines and corresponding filter coefficients. In one example, the sample lines to be filtered can be expanded 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} / 8; and for other lines, the filter coefficients can be {1, 2, 2, 2, 1} / 8, where line 0 represents the sample line closest to the boundary.

[0379] It should be noted that in JEM, samples are always filtered using reconstructed samples during the deblocking process. In one example, according to the techniques herein, filter unit 216 may be configured to use the modified sample values ​​resulting from deblocking to filter other sample values. In one example, the modified sample values ​​may be used as input when filtering other sample values. In one example, a filtering order may be specified. In one example, the filtering order may perform deblocking from the line farthest from the boundary to the line closest to the boundary.

[0380] As described above, the deblocked samples are typically clipped to be within a range of values. The range of values ​​may 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 of this document, the filter unit 216 may be configured to adjust the clipping function based on one or more of the following: sample values ​​in the last round or rounds in multi-pass domain deblocking; QP value; slice type; current prediction mode (intra / inter); current skip flag value; intra prediction mode of the sample to be deblocked; motion vector of the sample to be deblocked; sample position (e.g., different samples may use different clipping functions); CU position (e.g., different CUs may use different clipping functions); and / or any other conditions described above.

[0381] In one example, according to the techniques of this document, the 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, the determination of whether to perform the filtering technique may be as follows: (1) check each group of 4×4 samples on each side of the boundary (i.e., since the minimum CU size is 4×4 luma samples); (2) if any group of 4×4 samples belongs to a CU whose size is greater than a threshold (e.g., 64), the filtering technique will be performed on the current boundary. In one example, according to the techniques of this document, the 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 modes (intra / inter) of the current CU and its neighboring CUs; ​​sample positions to be deblocked.

[0382] In one example, according to the techniques herein, filter unit 216 may be configured to perform wider and stronger luma filtering as follows:

[0383] First, determine whether the P side utilizes large blocks as follows:

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

[0385] Next, determine whether the Q side utilizes large blocks as follows:

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

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

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

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

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

[0391] d0L=d0P+d0Q

[0392] d3L=d1P+dlQ

[0393] dL=d0L+d3L

[0394] Next, Condition1 and Condition2 are evaluated as follows:

[0395] Condition1=(dL<β)? TRUE:FALSE

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

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

[0398] When Condition1, Condition2, and bSideQisLargeBlk are TRUE, a wider and stronger filter is applied to the Q side of the boundary (e.g., WS00Q)

[0399] In one example, Condition2 may be modified as follows:

[0400] Condition2 = (When the blocks on either side of the boundary use local illumination compensation and the CBF of the block is 0)? TRUE: ((xUseStrongFilteringLargeBlock(R[0], d0L, bSidePisLargeBlk, bSideQisLargeBlk)&&xUseStrongFilteringLargeBlock(R[3], d3L, bSidePisLargeBlk, bSideQisLargeBlk))? TRUE: FALSE)

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

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

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

[0404] 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.

[0405] In one example, according to the techniques herein, filter unit 216 may be configured to Fig.10 The exemplary flowchart shown in FIG. 1 performs deblocking filtering. In one example, the filter unit 216 may be configured to Fig.10 The flowchart shown in performs deblocking filtering for luma samples. Fig.10 Examples are shown in which one of the following types of deblocking may be applied to a current block (e.g., one of a P block or a Q block): a wide stronger filter, a strong filter, a weak filter, or no filtering. In one example, applying a wide stronger 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, such as a weak filter described above. Fig.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 is true at 402, whether the large block gradient condition is true at 404, whether the large block strong filter condition is true at 406, whether the gradient condition is true at 410, and whether the strong filter condition is true at 414.

[0406] In one example, the chunk condition may 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)))

[0407] in

[0408] EDGE_VER is the vertical edge type,

[0409] EDGE_HOR is the horizontal edge type,

[0410] cur_block_width is the current block width, e.g. in luma samples,

[0411] cur_block_height is the current block height, e.g. in luma samples,

[0412] adjacent_block_width is the adjacent block width, e.g. in luma samples, and

[0413] adjacent_block_height is the adjacent block height, eg, in luma samples.

[0414] In one example, the bulk gradient condition may include whether the above Condition 1 is true. In one example, the bulk strong filter condition may include whether one of the above exemplary Condition! is true.

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

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

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

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

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

[0420] d0=d0P+d0Q;

[0421] d3=d1P+dlQ;

[0422] d = d0 + d3;

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

[0424] In one example, according to the techniques herein, filter unit 216 may be configured to Fig.11 The exemplary flowchart shown in FIG. 1 performs deblocking filtering. In an example, the filter unit 216 may be configured to Fig.11 The flowchart shown in performs deblocking filtering for chroma samples. Fig.11An example is shown in which one of the following types of deblocking may be applied for a current block (e.g., a P block or a Q block): a wide stronger filter or a weak filter. In one example, applying a wide stronger 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. Fig.11 As shown, a wider and stronger filter is applied at 504 and a weak filter is applied at 506 based on whether the large block condition at 502 is true.

[0425] In one example, the chunk condition may 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)))

[0426] in

[0427] EDGE_VER is the vertical boundary type, EDGEHOR is the horizontal boundary type, cur_block_width is the current block width, e.g., in chroma samples, cur_block_height is the current block height, e.g., in chroma samples, adjacent_block_width is the adjacent block width, e.g., in chroma samples, adjacent_block_height is the adjacent block height, e.g., in chroma samples.

[0428] In one example, filter unit 216 may be configured to perform deblocking filtering on chroma samples of a P block or a 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.

[0429] If ((EDGE_VER && (cur_P_block_width>=TH_w))||(EDGE_HOR && (cur_P_block_height>=TH_h)) is TRUE, then NS00P is applied to the P samples. Otherwise, a weak filter (eg, NW00P P-side filter) is applied to the P samples.

[0430] in

[0431] EDGE_VER is the vertical edge type,

[0432] EDGE_HOR is the horizontal edge type,

[0433] cur_Q_block_width is the current Q block width, e.g. in chroma samples,

[0434] cur_Q_block_height is the current Q block height, e.g. in chroma samples,

[0435] cur_P_block_width is the current P block width, e.g. in chroma samples,

[0436] cur_P_block_height is the current P block height, e.g. in chroma samples,

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

[0438] TH_h is the height threshold (eg, 32 samples).

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

[0440] refer to Fig.11 In one example, the large block condition may be replaced with a luma filter condition. That is, for example, if a strong filter is applied to a luma block, a wide, stronger filter may be applied to a collocated chroma block at 504, otherwise a weak filter may be applied to a collocated chroma block at 506.

[0441] In one example, according to the techniques herein, filter unit 216 may be configured to Fig.12 The exemplary flowchart shown in FIG. 1 performs deblocking filtering. In one example, the filter unit 216 may be configured to Fig.12 The flowchart shown in performs deblocking filtering for chroma samples. Fig.12 An example is shown in which one of the following types of deblocking may be applied for a current block (e.g., a P block or a Q block): a wide stronger filter or a weak filter. In one example, applying a wide stronger 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. Fig.12As shown, a wider stronger filter is applied at 608 and a weak filter is applied at 606 based on whether the large block condition is true at 602 and whether the large block strong filter condition is true at 604 .

[0442] In one example, the chunk condition may 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)))

[0443] in

[0444] EDGE_VER is the vertical edge type,

[0445] EDGE_HOR is the horizontal edge type,

[0446] cur_block_width is the current block width, e.g. in chroma samples,

[0447] cur_block_height is the current block height, e.g. in chroma samples,

[0448] adjacent_block_width is the adjacent block width, e.g. in chroma samples, and

[0449] adjacent_block_height is the adjacent block height, e.g. in chroma samples

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

[0451] TH_h is the height threshold (eg, 32 samples).

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

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

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

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

[0456] dp1 = xCalcDP(Rc[1]);

[0457] dq1 = xCalcDQ(Rc[1]);

[0458] d0=dp0+dq0;

[0459] dl=dp1+dq1;

[0460] d=d0+d1.

[0461] in,

[0462] R C [N] corresponds to a chroma line that is perpendicular to the edge being deblocked and is a distance N from the top of the current chroma segment being deblocked; and

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

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

[0465] It should be noted that in one example, the edges are deblocked into segments, where the segment length can be a function of the minimum size allowed for a CU / TU / PU / sub-PU. In addition, when 2×N and N×2 CUs are the shortest and thinnest blocks allowed in the chroma channels, the chroma segment length can be 2.

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

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

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

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

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

[0471] d0=dp0+dq0;

[0472] d3=dp3+dq3;

[0473] d=d0+d1.

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

[0475] As described above, in ITU-T H.265, the deblocking filter may be applied differently to CTU boundaries that coincide with slice boundaries and tile boundaries than to CTU boundaries that do not coincide with slice boundaries and tile boundaries. Specifically, in ITU-T H.265, slice_loop_filter_across_slices_enabled_flag enables / disables the deblocking filter across CTU boundaries that coincide with the top slice boundary and the left slice boundary. In one example, according to the techniques of this article, when the support samples of the deblocking filter exceed the boundary (e.g., picture / slice / tile), the deblocking filter that supports the sample may not be allowed to be used. In one example, according to the techniques of this article, when the support samples of the deblocking filter exceed the boundary (e.g., picture / slice / tile) and the use of sample values ​​across the boundary (e.g., slice) is disabled, a padding operation may be used to generate support sample values. For example, the supporting samples may be generated using one of digital scalar, circular, copy, or symmetric filling, where the digital scalar filling operation fills according to a constant value, the circular filling operation fills with a cyclic repetition of the sample value, the copy filling operation fills by repeating the boundary sample values, and the symmetric filling operation fills with a mirror reflection of the sample value.

[0476] As mentioned above, in ITU-T H.265, based on the value t C Specifically, for the strong filter in ITU-TH.265 mentioned above, p i 'The value is clipped to (pi -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, which is equal to: (QP Q +QP P +1) / 2. In some cases of video coding (e.g., proposed techniques for encoding high dynamic range (HDR) video), the value of QP may be changed at the CU level or CTU level. In these cases, the range of clipping operations provided based on the index Q in ITU-T H.265 may be insufficient. In one example, different t values ​​may be determined for P-side samples and Q-side samples according to the techniques herein. C ' value. That is, P side t C 'value, t CP ' and the corresponding P side t C Value, t Cp Can be used for clipping i 'Value and Q side t C 'value, t CQ’ , and corresponding Q side t C Value, t CQ Can be used to clip q i ' value. In one example, the corresponding P-side index QQ p and Q side index QQ q This can be done by substituting QP in the above Q index formula P and QP Q The corresponding value of qP L Therefore, according to the technology of this article, p i ' value can be clipped to (p i -2*t CP , p i +2*t Cp ) and q i ' 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 may include a filtered value generated according to any filter described herein. Thus, for use based on the corresponding tCP and t CQ Clipping i 'value and q i The 'value technique can be applied to any of the filters described herein.

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

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

[0479] As described above, the corresponding deblocked sample value y[n] with supporting samples may be specified based on the following equation:

[0480]

[0481] in,

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

[0483] coeff[m] provides the filter tap values ​​(also called filter coefficients);

[0484] x[n+m] provides the input sample value corresponding to the support sample.

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

[0486] In one example, if abs(x[n+m]-x[n]) is greater than a threshold, the term x[n+m] may be modified such that the supporting sample x[n+m] is excluded from the sum. It should be noted that in the case where coeff[m] corresponds to an average 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 excluding samples). It should be noted that in the case where coeff[m] corresponds to a Gaussian distribution (i.e.,

[0487]

[0488] , where the filter length is equal to abs(a-b+1). In one example, the term x[n+m] may be modified such that for each support sample x[n+m] (where abs(x[n+m]-x[n]) is greater than a 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 may be based on a combination of one or more of the following: a predefined value (e.g., 2 or 4), a value signaled in a parameter set, a value signaled in a slice header, a value based on a QP value (e.g., a QP value of a current sample and / or a support sample), and / or a value based on prediction information (e.g., an intra-prediction mode and / or motion information of a current sample and / or a support sample).

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

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

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

[0492] As mentioned above, in ITU-T H.265, for brightness, Bs, t C Each 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:

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

[0494] Whether to apply a strong or weak filter is determined based on the value of d_strong as follows:

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

[0496] - Apply strong filter;

[0497] -otherwise,

[0498] -Apply a weak filter.

[0499] In one example, according to the techniques herein, dStrong may be determined as follows:

[0500] 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));

[0501] With regard to the specific implementation of the deblocking filters in JEM, luma deblocking cannot be performed in parallel when one of the following conditions is valid, 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. That is, deblocking cannot be performed in parallel on two block boundaries because the filtering process of one boundary may involve samples that are deblocked by the filtering process of another boundary. Therefore, samples at the center of a block may be covered by two deblocking filters at each corresponding edge.

[0502] If (Cur_EDGE_VER && cur_block_width == 4), the current block vertical boundary will not be decoded in parallel;

[0503] If (Cur_EDGE_VER && adjacent_block_width == 4), adjacent block vertical boundaries will not be deblocked in parallel;

[0504] If (Cur_EDGE_HOR && cur_block_height == 4), the current block horizontal boundary will not be deblocked in parallel;

[0505] If (Cur_EDGE_HOR && adjacent_block_width == 4), adjacent block horizontal boundaries will not be deblocked in parallel;

[0506] in,

[0507] Cur_EDGE_VER is the current vertical boundary, Cur_EDGEHOR is the current horizontal boundary, cur_block_width is the current block width, e.g. in luma samples, cur_block_height is the current block height, e.g. in luma samples, adjacent-block_width is the adjacent block width, e.g. in luma samples, adjacent_block_height is the adjacent block height, e.g. in luma samples.

[0508] In one example, according to the techniques herein, for each of the above conditions, deblocking may be performed on luma samples at the boundary as follows:

[0509] If (Cur_EDGE-VER && cur-block_width == 4 && adjacent_block_width > 4), then for Cur_EDGE_VER only deblocking is performed on adjacent block samples;

[0510] If (Cur_EDGE_VER&&cur-block_width==4&&adjacent_block_width==4), no deblocking is performed for Cur_EDGE_VER;

[0511] If (Cur_EDGE_VER&&cur_block_width>4&&adjacent_block_width==4), then for Cur_EDGE_VER, deblocking is performed only on the current block samples;

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

[0513] If (Cur_EDGE_HOR && cur_block_height == 4 && adjacent_block_height > 4), then for Cur_EDGE_HOR, deblocking is performed only on adjacent block samples;

[0514] If (Cur_EDGE_HOR&&cur_block_height==4&&adjacent_block_height==4), Cur_EDGE_HOR does not perform deblocking;

[0515] If (Cur_EDGE_HOR&&cur_block_height>4&&adjacent_block_height==4), then for Cur_EDGE_HOR, deblocking is performed only on the current block samples;

[0516] If (Cur_EDGE_HOR&&cur_block_height>4&&adjacent_block_height>4), deblocking is performed on the current block samples and the adjacent block samples for Cur_EDGE_HOR.

[0517] In a manner similar to that described above, for chroma deblocking, parallel deblocking is limited when the corresponding cur_block_height, adjacent_block_height, cur_block_width, adjacent_block_width are equal to threshold 2. Therefore, according to the techniques herein, for chroma samples, deblocking may be performed as described above, where threshold 4 is replaced by threshold 2 in the conditional statement.

[0518] In one example, according to the techniques herein, instead of performing deblocking on the edges for blocks whose size is less than or equal to a threshold, a narrower filter may 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 may be performed as follows:

[0519] For Cur_EDGE_VER, deblocking is performed on neighboring block samples according to the filter width, and deblocking is performed on one neighboring column of samples at Cur_EDGE_VER for the current block.

[0520] In a similar manner, for each of the above cases, a narrower filter may be applied to samples at the edge. Thus, in general, in accordance with the techniques herein, a video encoder (and / or video decoder) may be configured to determine when parallel deblocking is limited, for example, due to overlapping deblocking filters (e.g., filter width is 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 may be limited based on samples available for deblocking support. In accordance with the techniques herein, a video encoder (and / or video decoder) may be configured to determine when parallel deblocking is limited to samples in a block that are available for deblocking support for multiple deblocking filters.

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

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

[0523] It should be noted that if the size of the q-side is 8 and the edge opposite to the current edge utilizes a strong HEVC filter, samples q5 and q6 may be modified by a strong HEVC deblocking operation for the opposite side. Deblocking edges that are parallel to each other cannot be processed in parallel. In one example, to prevent this from happening, the p-side should use a long filter (i.e., a stronger filter) only when the q-side length (perpendicular to the edge) is greater than or equal to 16. This condition (e.g., LargeBlk condition) is checked in one of the following ways:

[0524] LargeBlk condition: (the lengths of both sides of the edge perpendicular to the edge are both ≥ 16)?

[0525] TRUE: FALSE;

[0526] LargeBlk condition: (the lengths of both sides of the edge perpendicular to the edge are both ≥ 32)?

[0527] TRUE: FALSE;

[0528] OR

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

[0530] In one example, according to the techniques herein, a set of deblocking filters may utilize bilinear operations. In one example, for i=0 to S-1, the block boundary samples p i and q i The following is replaced by linear interpolation

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

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

[0533] In one example, f may be determined as provided in Table 1 i 、Middle s，t , P s , g i and Q t .

[0534]

[0535] Table 1

[0536] Referring to Table 1, it should be noted that for 7,5, 7,3, 5,3, 5,7 and 3,7, the pi and q for Middle i The weights of are different and are derived from 7,7 by adding an additional term.

[0537] In one example, according to the techniques herein, if either side is greater than or equal to 32, then a set of deblocking filters may utilize bilinear operations.

[0538] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 2.

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

[0540] Table 2

[0541] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 3.

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

[0543] Table 3

[0544] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 4.

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

[0546] Table 4

[0547] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 5.

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

[0549] Table 5

[0550] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 6.

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

[0552] Table 6

[0553] In one example, according to the techniques, when either side is greater than or equal to 32, bilinear deblocking may be performed as provided in Table 7.

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

[0555] Table 7

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

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

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

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

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

[0561] dq3=abs(q 2，3 -2*q l，3 +q 0，3 )

[0562] Then,

[0563] if (side p is greater than or equal to 16)

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

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

[0566] if (q side is greater than or equal to 16)

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

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

[0569] dpq0=dp0+dq0

[0570] dpq3=dp3+dq3

[0571] dp=dp0+dp3

[0572] dq=dq0+dq3

[0573] d=dpq0+dpq3

[0574] When d is less than β, the following sequential steps apply:

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

[0576] sp3=abs(p3-p0)

[0577] if (side p is greater than or equal to 16)

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

[0579] sq3=abs(q3-q0)

[0580] if (q side is greater than or equal to 16)

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

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

[0583] Note 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 sub-PU edges aligned with 8×8 (luma) and 4×4 (chroma) boundaries; deblocking of the edges of the current block may be based on the use of linear model (LM) chroma; deblocking of the edges of the current block may be based on the use of separate partitioning trees; deblocking of the edges of the current block may be based on the use of pulse code modulation (PCM); and / or deblocking of the edges of the current block may be based on the use of transform quantization bypass mode. It should be noted that PCM is a lossless coding mode for blocks of samples. In the example of PCM encoding, samples are directly represented by a predefined number of bits. The bit depth used for PCM may be signaled in a parameter set.

[0584] Regarding deblocking the edge of the current block based on the use of LM chroma and / or the deblocking of the edge of the current block may be based on the use of a separate partition tree, in one example, when LM chroma is used for chroma blocks and / or separate trees are used for luma and chroma and / or the received transform coefficient is zero, deblocking may be performed on the edge of the current block. Regarding in one example, for a separate tree, deblocking may be performed only on chroma edges (e.g., TU edges, PU edges, sub-PU edges, CU edges) that coincide with a 4×4 chroma grid.

[0585] In one example, when the large block condition is not TRUE and the strong filter condition is TRUE, then NS00P and NS00Q are used to deblock edges.

[0586] In one example, when the large block condition is not TRUE and the strong filter condition is TRUE, then (s, t) = 3, 3 filters are used to deblock edges.

[0587] It should be noted that in some cases, deblocking boundaries may include horizontal CTU boundaries. See, for example, Figure 5B In some cases, sample py,x may be included in a CTU that is above the CTU that includes sample qy,x. To encode the top line in the current CTU, a typical video encoder implementation stores N lines of samples in the bottom line of the CTU above the current CTU. For example, Figure 5BIn the case where the deblocking boundary in is a CTU boundary, the video encoder stores the value px,0 for performing intra-frame prediction coding of 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 specific implementation of the video encoder 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 prediction / unidirectional prediction, motion vector, reference index, etc.), block size, coefficient coding flag, etc.) is also stored. Therefore, in order to avoid increasing the specific implementation cost, 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 four lines of sample values, then a deblocking filter that needs to increase the CTU line buffer to store seven lines of sample values ​​will increase the implementation cost.

[0588] As mentioned above, JEM describes the coding features studied by JVET under the coordinated test model as potential enhanced video coding technologies beyond the capabilities of ITU-T H.265. In addition, in response to the "Joint Call for Proposals on Video Compression with Capabilities beyond HEVC" jointly issued by VCEG and MPEG, at the 10th meeting of ISO / IEC JTC1 / SC29 / WG11 held in San Diego, California, from April 16 to 20, 2018, various groups proposed various descriptions of video coding.

[0589] As a result of multiple descriptions of video coding, a draft text of a video coding specification is described in "Versatile Video Coding (Draft 1)", document JVET-J1001-v2, at the 10th meeting of ISO / IEC JTC1 / SC29 / WG11, held in San Diego, California, April 16-20, 2018, which is incorporated herein by reference and is referred to as JVET-J1001. "Versatile Video Coding (Draft 2)", document JVET-K1001-v4, at the 11th meeting of ISO / IEC JTC1 / SC29 / WG11, held in Ljubljana, SI, July 10-18, 2018, which is incorporated herein by reference and is referred to as JVET-K1001, is an update of JVET-J1001. 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 deblocking filter in the BMS modifies up to three samples perpendicular to the edge.

[0590] "CE2-related: Longer Tap Deblocking Filter", document JVET-K0369-r3 (referred to herein as JVET-K0369) from the 11th meeting of ISO / IEC JTC1 / 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. In addition, in order to limit the CTU line buffer size, the filter described in JVET-K0369 limits the filtering operation to horizontal edges that overlap with CTU boundaries. Specifically, JVET-K0369 describes a deblocking filter that modifies sample values ​​according to Table 8A and provides for modifying the position of the deblocking filter as shown in Table 8B for horizontal edges that overlap with CTU boundaries.

[0591]

[0592] Table 8A

[0593]

[0594] Table 8B

[0595] It should be noted that JVET-K0369 provides for horizontal edges overlapping CTU boundaries that modify the line buffer requirements for deblocking filters to not degrade chroma sample values. In addition, 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 additional filter banks for filtering CTU boundaries, which requires additional memory for storing coefficients.

[0596] In one example, according to the techniques of this document, the use of long tap filters may be limited, which may include modifying and / or having a filter support that supports at least three or more lines from px,0 to px,i. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && the current boundary is aligned with the CTU boundary), the long tap filter is not applied to the P side, where EDGE_TYPE is EDGE_HOR, indicating that the current boundary is a horizontal boundary. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && curPos.y% CTUSize in luma samples == 0), the long tap filter is not applied to P, where curPos.y is the vertical luma position of the current block to be deblocked. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && CTUsize==0 in curPosC.y% chroma samples), the long tap filter is not applied to P, where curPosC.y is the vertical chroma position of the current block to be deblocked. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && the current boundary is aligned with the CTU boundary), the long tap filter is not applied to the Q side and the P side. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && CTUsize==0 in curPos.y% luma samples), the long tap filter is not applied to the Q side and the P side. In one example, for luma and / or chroma deblocking, if the following conditions are met (EDGE_TYPE is EDGE_HOR && curPosC.y% CTUSize in chroma samples == 0), the long tap filter is not applied to the Q side and the P side. In one example, when the long tap filter is not applied, another filter that modifies fewer samples and / or includes filter support that utilizes fewer lines (e.g., one, two, or three lines) from px,0 to px,i is applied. For example, the weak filter or strong filter described herein may be applied in situations where the application of the long tap filter is not allowed. It should be noted that, as provided in ITU-T H.265, the % operand is modulo the operand, which provides the remainder of x divided by y.

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

[0598]

[0599] Table 9

[0600] Additionally, in one example, values ​​derived from the available sample values ​​may be used for the corresponding sample positions. In one example, for each of p4 to p7, the sample value may be set to the average sample value of p3 and p2, and the filter coefficients in Table 8A may be used to derive modified sample values ​​for p3′ to q2′.

[0601] In one example, when the long tap filter is not applied, the filtering process may 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 certain distance of the CTU horizontal boundary), and a corresponding filter may be selected that does not access / deblock samples that exceed the target line buffer threshold. For example, with respect to the example shown in Table 9, for p3′ and p2′, different rules may be applied by deriving sample values ​​for p4 to p7.

[0602] In one example, when the long tap filter is not applied, the control process may be modified based on the position of the sample being deblocked, and a corresponding filter may be selected that does not access / deblock samples exceeding the target line buffer threshold. For example, the (s=3, t=7) filter for luma in Table 1, the (s=3, t=5) filter for luma in Table 1, the F1P filter for luma, and / or the chroma weak filter for chroma may be selected.

[0603] In one example, when the long tap filter is not applied, the deblocking grid may be changed so that samples exceeding the target line buffer threshold are not accessed / deblocked. For example, the deblocking grid may be moved so that the horizontal edge is at a distance 4 below the horizontal CTU edge.

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

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

[0606] in,

[0607] cQpPicOffset is a variable that specifies the picture-level chroma quantization parameter offset, and

[0608] For Cb, cQpPicOffset = pps_cb_qp_offset, and

[0609] For Cr, cQpPicOffset = pps_cr_qp_offset

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

[0611] For chroma, use Figure 6 The table shown determines t C ', and as follows for t C 'Determine index Q:

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

[0613] The techniques proposed in each of JVET-J1001 and JVET-K1001 provide for situations where separate partitioning trees can be used to partition luma and chroma channels. In the case where separate partitioning trees are used to partition luma and chroma channels, it may be useful to increase the amount by which the QP value of the chroma channel changes relative to the QP value of the luma channel. That is, for example, the corresponding QP offset value of each component of the chroma channel may be increased, which offset value may 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 offset of the luma quantization parameter Qp′Y used to derive 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 (including the end values). When ChromaArrayType is equal to 0, pps_cb_qp_offset and pps_cr_qp_offset are not used in the decoding process and the decoder should ignore their values.

[0614] slice_cb_qp_offset specifies the difference to be added to the value of pps_cb_qp_offset when determining the value of the Qp′Cb quantization parameter. The value of slice_cb_qp_offset shall be in the range of -12 to +12, inclusive. When slice_cb_qp_offset is not present, it is inferred to be equal to 0. The value of pps_cb_qp_offset+slice_cb_qp_offset shall be in the range of -12 to +12, inclusive.

[0615] slice_cr_qp_offset specifies the difference to be added to the value of pps_cr_qp_offset when determining the value of the Qp′Cr quantization parameter. The value of slice_cr_qp_offset shall be in the range of -12 to +12, inclusive. When slice_cr_qp_offset is not present, it is inferred to be equal to 0. The value of pps_cr_qp_offset+slice_cr_qp_offset shall be in the range of -12 to +12, inclusive.

[0616] In the case where deblocking parameters are based on QP values, changes to the derivation of chroma QP values ​​may affect chroma channel deblocking. According to the techniques herein, the derivation of deblocking parameters based on QP values ​​may be modified, for example, in the case where separate partitioning trees may be used to partition luma and chroma channels.

[0617] In one example, according to the techniques herein, cQpPicOffset may be derived as follows:

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

[0619] For Cr, cQpPicOffset = pps_cr_qp_offset + slice_cr_qp_offset

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

[0621] For Cb, cQpPicOffset = pps_cb_qp_offset + slice_cb_qp_offset + CuQpOffset etcb

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

[0623] In some cases, additional luma and chroma QP offset values ​​may be used for blocks that undergo a type of processing (e.g., adaptive color transform). These QP offsets may be used to derive the QPs for luma and chroma. Thus, the deblocking process may depend on the additional luma and chroma QP offsets.

[0624] In some examples, when separate partitioning trees are used to partition the luma channel and the chroma channel, the chroma QP value may be calculated based on the partitioning tree type. For example, in one example, the chroma QP value may be determined as follows:

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

[0626] Among them, Qp blk_P , Qp blk_Q are the luma quantization parameters corresponding to the chroma blocks on the P side and the chroma blocks on the Q side, respectively.

[0627] In one example, Qp blk_P and / or Qp blk_Q It may be derived from a combination of one or more of the following: QP values ​​of a plurality of corresponding luma blocks;

[0628] The number of samples in the luma block corresponding to the chroma block; the luma QP value corresponding to the predetermined chroma position. In some examples, Qp blk_P and / or Qp blk_Q Function derivation may be used, such as integer average, maximum function with rounding function.It should be noted that it is possible to have partial luma blocks corresponding to chroma blocks. FIG. 14A to FIG. 14B An example of a possible luma partition corresponding to chroma blocks P and Q is shown, where each luma block has a QP value QP_X. Fig.14A In the example shown, chroma blocks P are collocated with luma blocks having QP values ​​QP_1 and QP_3, and chroma blocks Q are collocated with luma blocks having QP values ​​QP_2 and QP_4. Fig. 14B In the example shown, chroma blocks P are collocated with luma blocks having QP values ​​QP_1, QP_3, and QP_5, and chroma blocks Q are collocated with luma blocks having QP values ​​QP_2 and QP_4. Fig.14A For the example shown, Qp blk_P and Qp blk_Q It can be deduced as follows:

[0629] Q blk_P =(QP_1+QP_3+1)>>1

[0630] Q bik_Q =(QP_2+QP_4+1)>>1

[0631] In one example, for Fig. 14B For the example shown, Qp blk_P and Qp blk_Q It can be deduced as follows:

[0632] Q blk_P =(QP_1+QP_5+2*QP_3+2)>>1

[0633] Q blk_Q (QP_2+QP_4+1)>>1

[0634] In one example, Qp blk_P and / or Qp blk_Q The QP value can be derived by identifying a set of chrominance positions and identifying a corresponding luma position for each chrominance position. For each corresponding luma position, a corresponding QP value can be determined. The corresponding QP value can be used to derive QP blk_P and / or Qp blk_Q .

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

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

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

[0638] dp1 = xCalcDP(Rc[1]);

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

[0640] d0=dp0+dq0;

[0641] dl=dp1+dq1;

[0642] d=d0+d1.

[0643] in,

[0644] R C [N] corresponds to a chroma line that is perpendicular to the edge being deblocked and a distance N from the top of the current chroma 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:

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

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

[0647] d0=dp0+dq0:

[0648] d=d0+d1.

[0649] In some examples, a condition of x sample segments of chroma deblocking boundaries may be checked (e.g., x=2). This reduces the number of lines that need to calculate gradients in the worst case. It should be noted that in the worst case, the first condition will calculate gradients (xCalcDQP for each line), while the above conditions will calculate gradients every 2 lines.

[0650] As mentioned above, ITU-T H.265, variables β and t C For filtering decisions and clipping operations. For example, β and / or t C Used to determine whether to use a strong filter and / or for clipping the filtered sample values. It should be noted that in JVET-K1001, the peak signal-to-noise ratio (PSNR) is higher for a given quantization level compared to ITU-T H.265. Therefore, in some cases, modifying β and / or t CIn order to modify the deblocking strength it may be useful. That is, if the distortion level is lower at a given quantization level, the perceived amount of blocking artifacts is lower, and therefore less deblocking is required. In one example, β may be modified as follows: β = β < < n. In one example, β may be modified as follows: β = β >> n. In one example, t may be modified as follows C :t C =t C <<n. In one example, t may be modified as follows C :t C =t C >>n. In one example, n may be determined based on a combination of one or more of the following: slice type, QP value, block size, bit depth, intra 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 slicing, 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 chrominance components.

[0651] "CE2-2.1.1: Long deblocking filters and fixes" from the 11th ISO / IEC JTCl / SC29 / WG11 meeting held in Ljubljana, Slovenia from July 10 to 18, 2018, document JVET-K0307-vl (referred to as JVET-K0307 in this article) describes long filters and decisions for the luma component.

[0652] Based on the above 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 deblocked on the larger block side is greater than the number of samples deblocked on the smaller block side. The deblocking decision process selected from the extended filter bank is described in detail below. The extended filter bank can be used for strong deblocking in the entire deblocking process.

[0653] In one example, according to the techniques herein, a stronger filter for luminance is used when there are large blocks on either side and the modified strong filter condition is satisfied. In one example, the luminance large blocks correspond to a vertical edge width of >= 32 and a horizontal edge height of >= 32.

[0654] In one example, a filter with stronger brightness may be defined as follows:

[0655] Then, for i=0 to S-1, the block boundary samples p i and q i It is replaced by linear interpolation as follows:

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

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

[0658] Wherein f_i, Middle_s, t, P_s and Q_s are given in the following Table 10:

[0659]

[0660] Table 10

[0661] In one example, the control process is also based on the gradients calculated for two lines of four sample segments; the absolute pixel value difference and t C ; and other absolute pixel value differences compared with β. More gradients are calculated for the large block side. The control process can be as follows:

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

[0663] First, dp0, dp3, dq0, dq3 are derived as in ITU-T H.265

[0664] Then dpq0, dpq3, dp, dq, ...

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

[0666] a. Dpq is derived as in ITU-T H.265.

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

[0668] if (p side is greater than or equal to 32)

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

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

[0671] if (q side is greater than or equal to 32)

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

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

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

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

[0676] Set dSq1, dSq2 to Abs(q3-q0)

[0677] if (q side is greater than or equal to 32)

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

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

[0680] if (p side is greater than or equal to 32)

[0681] dSpl=abs(p4-2*p2+p0)

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

[0683] Calculate d_strong1 and d_strong2 as follows:

[0684] d_strong1=dSp1+dSq1

[0685] d_strong2=dSp2+dSq2

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

[0687] f. When StrongFilterCondition is TRUE, a filter with stronger brightness is used (which can be selected based on the block size at the edge boundary).

[0688] In one example, the control process may be as follows:

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

[0690] First, dp0, dp3, dq0, dq3 are derived as in ITU-T H.265

[0691] Then dpq0, dpq3, dp, dq, ...

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

[0693] dpq is derived as in ITU-T H.265.

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

[0695] if (p side is greater than or equal to 32 && q side is greater than or equal to 16)

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

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

[0698] if (q side is greater than or equal to 32 && p side is greater than or equal to 16)

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

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

[0701] 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 filter with stronger brightness can be applied. It should be noted that in other examples, additional conditions (e.g., one or more previous conditions) may be used to determine whether a filter with stronger brightness can be applied. In one example, the additional conditions may be as follows:

[0702] If (p-side is greater than or equal to 32 && q-side is greater than or equal to 16) || (q-side is greater than or equal to 32 && p-side is greater than or equal to 16); however, for (7, 7, 7, 3, 3, 7), the decision process is (p-side is greater than or equal to 32 || q-side is greater than or equal to 32). The idea is that the lower threshold of 3*β>>5 instead of β>>3 selects which of these brighter filters is applied before the decision process.

[0703] In one example, according to the techniques described herein, luma can be deblocked according to a 4×4 luma sample grid (or in some examples, according to an 8×8 luma sample grid). In this example, a luma stronger filter 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 vertical edges with a width of >= 32, horizontal edges with a height of >= 32, and neighboring blocks greater than or equal to 16. The control process can also be based on the gradients calculated for two lines of four sample segments; the absolute pixel value difference and t C and other absolute pixel value differences with β, as described in further detail below. In addition, when p0 belongs to a CTU higher than the current CTU, the following limited support brightness filter provided in Table 8B above may be used.

[0704] In some cases, a subset of samples is not accessible. In such cases, the control process that uses the subset of samples may be affected. This may lead to asymmetry in the gradient calculation. In some examples, in this case, another control process may be used.

[0705] In one example, the control process may be as follows:

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

[0707] First, dp0, dp3, dq0, dq3 are derived as in ITU-T H.265

[0708] LongTapDeblocking=((p side>=32&&q side>=16)||(p side>=16&&q side>=32)))?

[0709] TRUE: FALSE

[0710] ControlSamplesAccessible = p0 belongs to a CTU higher than the current CTU? FALSE: TRUE

[0711] if (LongTapDeblocking)

[0712] if (p side greater than or equal to 32 && ControlSamplesAccessible)

[0713] dp0=(dp0+Abs(p 5.0 -2*P 4，0 +P 3，0 )+1)>>1

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

[0715] if (q side is greater than or equal to 32)

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

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

[0718] Then dpq0, dpq3, dp, dq, ...

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

[0720] dpq is derived as in ITU-T H.265.

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

[0722] if (p side greater than or equal to 32 && LongTapDeblocking && ControlSamplesAccessible)

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

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

[0725] if (q side is greater than or equal to 32 && LongTapDeblocking)

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

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

[0728] When StrongFilterCondition is TRUE and LongTapDeblocking is TRUE, a filter with a stronger brightness is used on the side perpendicular to the boundary edge whose length is greater than or equal to 32.

[0729] Otherwise, when StrongFilterCondition is TRUE and LongTapDeblocking is FALSE, another strong filter (eg, HEVC strong filter HEVC_P, HEVC_Q) is used.

[0730] In one example, the threshold used for comparison may also be based on position, for example, whether the edge being deblocked is aligned with a CTU boundary.

[0731] In one example, a 4×4 luma deblocking grid may require one of the following:

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

[0733] When the block width / height is equal to 4 for vertical / horizontal edges respectively, then at most three samples are used in the filter decision and the filter modifies only one sample, i.e., Used to replace the strong / weak filter condition check And only strong and weak filters are allowed to modify p0 and q0

[0734] In one example, according to the techniques described herein, chroma may be deblocked according to a 2×2 chroma sample grid (or, in some examples, according to a 4×4 luma sample grid). In this example, the HEVC_P P-side filter and HEVC_Q Q-side filter described above may be used. In addition, when p0 belongs to a CTU higher than the current CTU, the chroma weak filter described above as NW00P may be used. In one example, the strong filter may be used when the HEVC luma strong filter condition calculated for chroma is true and any of the following conditions is true:

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

[0736] - Edge type is horizontal, and p0 belongs to a CU with height >= 16 (chroma samples), q0 belongs to a CU with height >= 16 (chroma samples)

[0737] See again Figure 8 , the entropy coding unit 218 receives the 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 the scan. The entropy coding unit 218 may be configured to perform entropy coding according to one or more of the techniques described herein. As such, the video encoder 200 represents an example of a device that is configured to receive an array of sample values ​​including adjacent reconstructed video blocks for a video data component, and to modify the sample values ​​in the adjacent reconstructed video blocks according to multiple passes of a deblocking filter.

[0738] See again Figure 7 , the data encapsulator 107 can receive the encoded video data and generate a compatible bitstream according to a defined data structure, for example, a sequence of NAL units. A device receiving the compatible bitstream can reproduce the video data therefrom. In addition, the device receiving the compatible bitstream can perform a sub-bitstream extraction process, wherein the sub-bitstream extraction refers to a process in 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 conforming bitstream can be used instead of the term compatible bitstream.

[0739] See again Figure 7, the interface 108 may include any device configured to receive the data generated by the data encapsulator 107 and transmit and / or store the data to a communication medium. The interface 108 may include a network interface card such as an Ethernet card, and may include an optical transceiver, a radio frequency transceiver, or any other type of device that can transmit and / or receive information. In addition, the interface 108 may include a computer system interface that enables files to be stored on a storage device. For example, the interface 108 may include a chipset that supports the peripheral component interconnect (PCI) and peripheral component express interconnect (PCIe) bus protocols, a dedicated bus protocol, a universal serial bus (USB) protocol, FC, or any other logical and physical structure that can be used to interconnect peer devices.

[0740] See again Figure 7 , target device 120 includes interface 122, data decapsulator 123, video decoder 124 and 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, a radio frequency transceiver or any other type of device that can receive and / or send information. In addition, interface 122 may include a computer system interface that allows compatible video bitstreams to be retrieved from a storage device. For example, interface 122 may include a chipset that supports PCI and PCIe bus protocols, dedicated bus protocols, USB protocols, FC, 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 exemplary parameter set described herein.

[0741] Video decoder 124 may include any device configured to receive a bitstream and / or a variant thereof that it can accept and 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, the video decoder 124 is described as outputting data to a display 126, but the video decoder 124 can be configured to output video data to various types of devices and / or subcomponents thereof. For example, the video decoder 124 can be configured to output video data to any communication medium, as described herein.

[0742] Fig. 9 is a block diagram illustrating an example of a video decoder that may be configured to decode video data in accordance with one or more techniques of this disclosure.

[0743] In one example, the video decoder 300 may be configured to decode the transform data and reconstruct residual data from the transform coefficients based on the decoded transform data. The video decoder 300 may be configured to perform intra-frame prediction decoding and inter-frame prediction decoding, and thus may be referred to as a hybrid decoder. Fig. 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 a video encoding system. It should be noted that although the exemplary video decoder 300 is shown with different functional blocks, such illustrations are intended for descriptive purposes and do not limit the video decoder 300 and / or its subcomponents to a specific hardware or software architecture. The functionality of the video decoder 300 can be implemented using any combination of hardware, firmware, and / or software implementations.

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

[0745] See again Fig. 9, the reconstructed residual data may be provided to the summer 312. The summer 312 may add the reconstructed residual data to the predicted video block and generate reconstructed video data. The predicted video block may be determined according to a predictive video technique, namely intra prediction and inter prediction. The intra prediction processing unit 308 may be configured to receive an intra prediction syntax element and retrieve the predicted video block from a reference buffer 316. The reference buffer 316 may include a memory device configured to store one or more frames of video data. The intra prediction syntax element may identify an intra prediction mode, such as the intra prediction mode described above. The inter prediction processing unit 308 may receive the inter prediction syntax element and generate a motion vector to identify a predicted block in one or more reference frames stored in the reference buffer 316. The inter prediction processing unit 310 may generate a motion compensated block, possibly performing interpolation based on an interpolation filter. An identifier of an interpolation filter for motion estimation with sub-pixel precision may be included in the syntax element. The inter prediction processing unit 310 may use an interpolation filter to calculate an interpolated value of a sub-integer pixel of a reference block.

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

[0747] In one or more examples, the functions may be implemented by hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored as one or more instructions or codes on or transmitted via a computer-readable medium and executed by a hardware-based processing unit. Computer-readable media may include computer-readable storage media corresponding to tangible media such as data storage media, or propagation media including any medium that facilitates the transmission of a computer program from one place to another, for example, according to a communication protocol. Thus, computer-readable media 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. The 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, codes, and / or data structures for implementing the techniques described in the present disclosure. A computer program product may include a computer-readable medium.

[0748] By way of example and not limitation, such computer-readable storage media may include RAM, ROM, EEPROM, CD-ROM or other optical disk storage devices, disk storage devices or other magnetic storage devices, flash memory, or any other medium that can be used to store the required program code in the form of instructions or data structures and can be accessed by a computer. Moreover, any connection is appropriately referred to as a computer-readable medium. For example, if a coaxial cable, optical fiber cable, twisted pair, digital subscriber line (DSL) or wireless technology such as infrared, radio and microwave are used to transmit instructions from a website, server or other remote source, then coaxial cable, optical fiber cable, twisted pair, DSL or wireless technology such as infrared, radio and microwave are included in the definition of medium. However, it should be understood that computer-readable storage media and data storage media do not include connections, carriers, signals or other transient media, but are directed to non-transient tangible storage media. As used herein, disks and optical disks include compact disks (CDs), laser disks, optical optical disks, digital versatile disks (DVDs), floppy disks and Blu-ray disks, wherein disks usually copy data magnetically, while optical disks use lasers to copy data optically. The above combination should also be included in the scope of computer-readable media.

[0749] Instructions may 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 logic arrays (FPGAs), or other equivalent integrated or discrete logic circuits. Therefore, the term "processor" as used herein may refer to any of the aforementioned structures or any other structure suitable for implementing the techniques described herein. In addition, in some aspects, the functions described herein may be provided within dedicated hardware and / or software modules configured for encoding and decoding, or incorporated into a combined codec. Moreover, these techniques may be implemented entirely in one or more circuits or logic elements.

[0750] The techniques of the present disclosure may be implemented in a variety of devices or apparatuses including wireless handsets, integrated circuits (ICs), or a set of ICs (e.g., chipsets). Various components, modules, or units are described in the present disclosure to emphasize functional aspects of devices configured to perform the disclosed techniques, but do not necessarily need to be implemented by different hardware units. Instead, as described above, the various units may be combined in a codec hardware unit, or provided by a collection of interoperable hardware units including one or more processors as described above, in combination with appropriate software and / or firmware.

[0751] In addition, each functional block or various features of the base station equipment and terminal equipment used in each of the above-mentioned embodiments can be implemented or executed by a circuit (usually an integrated circuit or multiple integrated circuits). The circuit designed to perform the functions described in this specification may include a general-purpose processor, a digital signal processor (DSP), a dedicated or general-purpose integrated circuit (ASIC), a field programmable gate array (FPGA), or other programmable logic devices, discrete gates or transistor logic devices, or discrete hardware components, or a combination thereof. The general-purpose processor may be a microprocessor, or alternatively, the processor may be a conventional processor, a controller, a microcontroller or a state machine. The general-purpose processor or each of the above-mentioned circuits may be configured by a digital circuit, or may be configured by an analog circuit. In addition, when the technology of the integrated circuit that replaces the current integrated circuit appears due to the progress of semiconductor technology, the integrated circuit produced by the technology can also be used.

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

[0753] <Cross Reference>

[0754] This nonprovisional application is a nonprovisional application filed pursuant to 35 U.S.C. § 119 and is a nonprovisional application to which the present application is entitled pursuant to 35 U.S.C. § 119 and which is a nonprovisional application to which the present application is entitled pursuant to 35 U.S.C. § 119 and which is a nonprovisional application to which the present application is entitled pursuant to 35 U.S.C. § 119 and which is a nonprovisional application to which the present application is entitled pursuant to 35 U.S.C. § 119 and which is a nonprovisional application to which the present application is entitled 9,716, 62 / 696,309 on July 10, 2018, 62 / 711,420 on July 27, 2018, 62 / 714,755 on August 5, 2018, 62 / 732,556 on September 17, 2018, 62 / 733,067 on September 18, 2018, 62 / 735,090 on September 22, 2018, and 62 / 737,596 on 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: receiving sample values ​​included in a first block and a second block adjacent to a block boundary in the reconstructed video data; determining whether the first block is a large block based on whether a dimension of the first block perpendicular to the block boundary is greater than or equal to 32 samples; determining whether the second block is a large block based on whether a dimension of the second block perpendicular to the block boundary is greater than or equal to 32 samples; Calculating the gradient of the first block; Calculating the gradient of the second block; Derivation of variable beta based on quantitative parameters; Set the threshold to one of the following: In the case where one of the first block or the second block is a large video block, the threshold is set to (3*beta>>5), or In a case where neither the first block nor the second block is a large video block, setting the threshold to (beta>>3); Based on whether the sum of the gradient of the first block and the gradient of the second block is less than the threshold, it is determined whether to filter each sample in the first block and the second block according to linear interpolation.

2. A device comprising one or more processors, the processors being configured to: receiving sample values ​​included in a first block and a second block adjacent to a block boundary in the reconstructed video data; determining whether the first block is a large block based on whether a dimension of the first block perpendicular to the block boundary is greater than or equal to 32 samples; determining whether the second block is a large block based on whether a dimension of the second block perpendicular to the block boundary is greater than or equal to 32 samples; Calculating the gradient of the first block; Calculating the gradient of the second block; IA231308 Derivation of variable beta based on quantitative parameters; Set the threshold to one of the following: In the case where one of the first block or the second block is a large video block, the threshold is set to (3*beta>>5), or In a case where neither the first block nor the second block is a large video block, setting the threshold to (beta>>3); Based on whether the sum of the gradient of the first block and the gradient of the second block is less than the threshold, it is determined whether to filter each sample in the first block and the second block according to linear interpolation.

Images