RU2812618C2 - Nonlinear adaptive contour filtering in video data processing - Google Patents

Abstract

FIELD: video data processing technologies.

SUBSTANCE: encoding the video block of video as an encoded video block; generating reconstruction samples from the encoded video block; performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block samples; applying a nonlinear adaptive contour filter to the output result of the constraint operation and generating an encoded video representation using the encoded video block.

EFFECT: increase of efficiency of video encoding.

15 cl, 19 dwg, 2 tbl

Description

Field of technology to which the invention relates

This patent document relates to video processing technologies, devices and systems.

State of the art

Despite advances in video compression, digital video still relies on the largest bandwidth available on the Internet and other digital communications networks. As the number of connected user devices capable of receiving and displaying video increases, the demand for bandwidth for digital video use is expected to continue to increase.

Disclosure of the invention

Devices, systems and methods associated with digital video processing and, for example, nonlinear adaptive contour filtering for processing video data are described. The described methods can be applied to both existing video coding standards (for example, High Efficiency Video Coding (HEVC) standards) and future standards (for example, Versatile Video Coding (VVC)) or codecs.

In one exemplary approach, the disclosed technology may be used to provide a method for processing video data. This method comprises the steps of: encoding a video block of video in the form of an encoded video block; generating reconstruction samples from the encoded video block; performing constraint operations on the reconstruction samples, in which the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block samples; applying a nonlinear adaptive loop filter to the result of the constraint operation; and generating an encoded video representation using the encoded video block.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises the steps of parsing an encoded video representation for an encoded video block representing a video video block; generating video block reconstruction samples from the encoded video block; performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block; and applying a nonlinear adaptive contour filter to the result of the limiting operation to form a final decoded video block.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises: converting between an encoded representation of a video containing one or more video regions and a video; and determining a constraint parameter for filtering the reconstruction of the video block of the video region using a nonlinear adaptive contour filter, the determination being based on encoded information of the video and/or video region and/or video block.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises: converting between an encoded representation of a video containing one or more video regions and a video; and determining a constraint parameter for filtering the reconstruction of the video block of the video region using a nonlinear adaptive edge filter, wherein the constraint parameter is a function of the color format of the representation.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises: converting between an encoded representation of a video containing one or more video regions and a video; and determining a constraint parameter for filtering the reconstruction of the video block of the video region using a nonlinear adaptive loop filter, wherein the constraint parameter depends on whether in-loop reshaping (ILR) is applied to reconstruct the video block based on the representation of the video block in the first region and in the second region and/or scaling the remaining chrominance of the video chrominance block.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises converting between an encoded representation of a video comprising one or more video regions and a video, the encoded representation comprising first side information that provides a constraint parameter for filtering the reconstruction of a video block of the video region using a nonlinear adaptive edge filter; wherein the first side information is reported together with the second side information indicating filter coefficients used in the nonlinear adaptive loop filter.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises converting between an encoded representation of a video comprising one or more video regions, and a video, wherein the encoded representation contains side information indicating a plurality of constraint parameter sets for filtering the reconstruction and video block of the video region using a nonlinear adaptive edge filter.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises converting between an encoded video representation containing one or more video regions and a video; wherein the encoded representation contains side information that provides one or more constraint parameters for filtering the reconstruction of a video domain chrominance video block using a nonlinear adaptive edge filter, wherein said one or more constraint parameters are color format dependent.

In another approach, the disclosed technology may be used to provide a method for processing video data. The method comprises converting between an encoded representation of a video comprising one or more video regions and a video, the encoded representation comprising side information that provides a constraint parameter for filtering the reconstruction of a video block of the video region using an adaptive edge filter; in this case, at the execution stage, a filtered video block is formed by applying a constraint operation to the sample differences at the video area level.

In yet another exemplary approach, the method described above is implemented as processor-executable code and stored on a computer-readable storage medium.

In yet another exemplary approach, a device configured or operable to perform the method described above is disclosed. The device may include a processor that is programmed to implement the method.

In yet another exemplary approach, one or more of the methods disclosed above may be an encoder-side implementation or a decoder-side implementation.

The above and other approaches and features of the disclosed technology are described in more detail in the drawings, description and claims.

Brief description of drawings

Fig. 1 is an exemplary block diagram of an encoder for video encoding.

Fig. 2A, 2B, and 2C are examples of geometry transformation-based adaptive loop filter (GALF) shapes.

Fig. 3 is an example of a flowchart for decision making by a GALF encoder.

Fig. 4A-4D are an example of Laplacian subsample calculations for adaptive loop filter (ALF) classification.

Fig. 5 is an example of a brightness signal filter shape.

Fig. 6 is an example of dividing into areas with a resolution sequence of 800x480 (Wide Video Graphic Array, WVGA).

Fig. 7 is an example of a flowchart for performing decoding operations using reshaping.

Fig. 8A-8C are flowcharts of exemplary methods for processing video signals in accordance with certain implementations of the disclosed technology.

Fig. 9 is a flowchart of an exemplary method of processing video signals in accordance with certain implementations of the disclosed technology.

Fig. 10A and 10B are block diagrams of examples of a hardware platform for implementing video signal processing technology in the present document.

Carrying out the invention

Due to the growing demand for higher resolution video, video encoding methods and methods have become widespread in modern technology. Video codecs typically contain electronic circuitry or software that compresses or decompresses digital video signals and is continually being improved to provide improved encoding efficiency. A video codec converts an uncompressed video signal into a compressed format or vice versa. There are complex relationships between video quality, the amount of data used to represent the video (determined by bit rate), the complexity of encoding and decoding algorithms, sensitivity to data loss and errors, ease of editing, random access, and end-to-end latency. The compressed format typically follows a video compression specification standard, such as High Efficiency Video Coding (HEVC) (also known as H.265 or MPEG-H Part 2), Versatile Video Coding (VVC), to be completed, or other current and/or future video coding standards.

In some embodiments, future video encoding technologies are applied using reference software known as the Joint Exploration Model (JEM). According to JEM, subblock based prediction is used in several coding tools such as affine prediction, alternative temporal motion vector prediction (ATMVP), spatial-temporal motion vector prediction (STMVP) ), bi-directional optical flow (BIO), Frame-Rate Up Conversion (FRUC), Locally Adaptive Motion Vector Resolution (LAMVR), overlay motion compensation Overlapped Block Motion Compensation (OBMC), Local Illumination Compensation (LIC) and Decoder-side Motion Vector refinement (DMVR).

Embodiments of the disclosed technology may be applied to existing video coding standards (eg, HEVC, H.265) and to future standards, standards to improve runtime performance. Section headings are used herein to enhance the reading of the specification and in no way limit the discussion or embodiments (and/or implementations) to the relevant sections.

1 Examples of obtaining subsamples of color space and chromaticity

A color space, also known as a color model (or color system), is an abstract mathematical model that simply describes a range of colors as sets of n elements, typically 3 or 4 values or color components (such as RGB). Essentially speaking, color space is a development of the coordinate system and subspace.

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

YCbCr, Y′CbCr or Y Pb/Cb Pr/Cr, also written as YCBCR or Y'CBCR, is also a family of color spaces used as part of color image promotion in video and digital photography systems. Y′ is the luminance component, and CB and CR are the blue-difference and red-difference color components. Y′ (with primary color) is different from Y, which is luminance, meaning that light intensity is encoded nonlinearly based on gamma-corrected RGB primary colors.

Chroma subsampling is a practical application of encoded images that implements lower resolution for chroma information than for luminance information, favoring the lower resolution of the human visual system in distinguishing colors over luminance.

1.1 4:4:4 color format

Each of the three Y'CbCr components has the same sample rate, so no chromaticity subsample exists. This circuit is sometimes used in high-quality film scanners and in cinematography final editing.

1.2 4:2:2 color format

The two chrominance components are sampled at half the chrominance sampling rate, eg, at half the horizontal chroma resolution. This reduces the bandwidth of the uncompressed video signal by one third with almost no visual difference.

1.3 4:2:0 color format

In 4:2:0, the horizontal samples are doubled compared to 4:1:1, but since in this scheme the Cb and Cr channels are sampled only for each alternating line, the vertical resolution becomes half. The data frequency is therefore the same. Each of Cb and Cr is counted by a factor of 2 both horizontally and vertically. There are three variations of the 4:2:0 layout, each with a different horizontal and vertical layout.

- In MPEG-2, Cb and Cr are combined horizontally. Cb and Cr are located between the pixels in the vertical direction (arranged in the order of arrival).

- In JPEG/JFIF, H.261 and MPEG, Cb and Cr are placed in the order of arrival, halfway between the alternating luminance samples.

- In 4:2:0 DV Cb and Cr are placed together in the horizontal direction. In the vertical direction they are arranged together on alternating lines.

2 Examples of a typical video codec encoding stream

In fig. Figure 1 shows an example block diagram of a VVC encoder. As shown in FIG. 1, a video encoding stream may begin with an input video that is subject to intra-frame prediction and/or motion estimation/motion compensation (ME/MC). These operations use feedback from a reconstructed copy of a previously encoded portion of the video. The intra-prediction and/or ME/MC output signals are processed differently through a transform operation (T) followed by a quantization operation (Q), which is statistically encoded into the output encoded representation. In the feedback loop, the encoded representation (the output of the Q block) can be passed through an inverse quantization (IQ) operation followed by an inverse transform (IT) operation to generate reconstruction samples of the encoded video blocks.

The reconstructed samples may be further processed through various "loop" filtering operations to form reference samples or reference blocks or reference images used for additional encoding. The loop filtering process chain contains three loop filtering blocks: a deblocking filter (DF), a sample adaptive offset (SAO) block, and ALF. Unlike DF, which uses predefined filters, SAO and ALF use the original samples of the current image to reduce the rms errors between the original samples and the reconstructed samples by adding an offset and applying a finite impulse response (FIR) filter, respectively. using coded side information providing offsets and filter coefficients. ALF is located at the last stage of processing of each image and can be considered as a tool that attempts to capture and fix the artifacts created in the previous stages.

On the decoder side, several encoding operations are performed in reverse order to generate decoded and reconstructed video samples. For example, referring to FIG. 1, the decoder can parse the encoded image that is the result of entropy encoding and obtain encoded video blocks, which then undergo an inverse quantization (IQ) operation and an inverse transformation (IT) operation to form video block reconstruction samples. The final decoded video block can be generated using loop filtering operations as described above with respect to the video encoder feedback loop.

3 Examples of a geometry-transformation-based adaptive loop filter in JEM

According to JEM, a geometry transformation-based adaptive loop filter (GALF) is used with block-based filter adaptation. For the luminance component, one of 25 filters is selected for each 2x2 block based on the direction and activity of the local gradients.

3.1 Examples of filter shape

According to JEM, up to three diamond filter shapes can be selected for the luminance component (as shown in FIGS. 2A, 2B, and 2C for the 5x5 diamond, 7x7 diamond, and 9x9 diamond, respectively). The index is reported at the image level to indicate the shape of the filter used for the luminance component. The chrominance component of an image always uses a 5x5 diamond shape.

3.1.1 Block classification

Each 2x2 block is classified into one of 25 classes. The classification index C is obtained based on its directionality D and the quantized activity value as below:

. (1)

To calculate D and , using the one-dimensional Laplacian, first calculate the gradients of the horizontal, vertical and two diagonal directions:

(2)

(3)

(4)

(5)

The indices i and j refer to the coordinates of the top left sample in the 2x2 block and R(i, j) indicates the reconstructed sample at coordinate (i, j).

Then the maximum and minimum D values of the horizontal and vertical direction gradient are set as follows:

, , (6)

and the maximum and minimum gradient values of the two diagonal directions are set as follows:

, , (7)

To obtain the directivity value D, these values are compared with respect to each other and with two thresholds t ₁ and t ₂ .

Stage 1: If both And are true, D is set to 0.

Stage 2. If , continue from step 3; otherwise, continue with step 4.

Stage 3. If , D set equal to 2; otherwise, set D to 1.

Stage 4. If , D set equal to 4; otherwise, set D to 3.

The activity value A is calculated as follows:

(8)

And it is additionally quantized in the range from 0 to 4, inclusive, and the quantized value is denoted as .

For both chrominance components in the image, no classification method is applied, that is, for each chrominance component, one single set of ALF coefficients is applied.

3.1.2 Geometric transformations of filter coefficients

Before filtering each 2x2 block, geometric transformations such as rotation or diagonal or vertical flip are applied to the coefficients f(k,l), depending on the values calculated for that block. This is equivalent to applying these transformations to the samples in the filter support region. The idea is to make the different blocks to which ALF is applied more similar by aligning their directionality.

Three geometric transformations, including diagonal, vertical flip and rotation, are introduced as follows:

Here, K is the filter size and 0 ≤ k, l ≤ –1 are the coordinates of the coefficients, so that the location (0, 0) is in the upper left corner and the location (K – 1, K – 1) is in the lower right corner of the Transform are applied to the filter coefficients f(k, l) depending on the gradient values computed for that block. The relationship between the transformation and the four gradients of the four directions is summarized in Table 1.

Table 1. Representation of the gradient calculated for one block and transformation

Gradient value Conversion g _d2 < g _d1 and g _h < g _v No conversion g _d2 < g _d1 and g _v < g _h Diagonal g _d1 < g _d2 and g _h < g _v Vertical flip g _d1 < g _d2 and g _v < g _h Rotation

3.1.3 Message of filter parameters

According to JEM, the GALF filter parameters are reported for the first CTU, that is, after the fragment header and before the SAO parameters of the first CTU. Up to 25 sets of luminance filter coefficients can be reported. To reduce bit overhead, filter coefficients of other classifications may be combined. In addition, the GALF coefficients of the reference pictures are stored and resolved for reuse as the GALF coefficients of the current picture. The current picture may be selected to use the GALF coefficients stored for the reference pictures and bypass the GALF coefficient signaling. In this case, only the index in one of the reference pictures is signaled and the stored GALF coefficients of the specified reference picture are applied to the current picture.

To support GALF temporal prediction, a list of possible GALF filter set candidates is maintained. At the beginning of decoding a new sequence, the list of candidates is empty. After decoding one image, an appropriate set of filters can be added to the candidate list. When the size of the candidate list reaches the maximum allowed value (for example, 6 in the current JEM), the new set of filters overwrites the oldest set in decoding order and, that is, the first-in-first-out rule is applied to update the candidate list. first-out, FIFO). To avoid duplications, a set can only be added to the list when the corresponding image uses GALF temporal prediction. To support temporal scalability, there are multiple lists of possible filter set candidates, and each list is associated with a temporal layer. More specifically, the matrix designated by the layer's temporary index (TempIdx) may consist of filter banks of previously decoded images with an equal or lesser TempIdx index. For example, the kth matrix is assigned to be associated with a TempIdx equal to k, and it contains only filter banks from images with a TempIdx less than or equal to k. After encoding a particular image, the filter sets associated with the image will be used to update these matrices associated with an equal or higher TempIdx.

Temporal prediction of GALF coefficients is used for interframe coded frames to minimize signaling overhead. For intra-frame encoded frames, temporal prediction is not available and each class is assigned a set of 16 fixed filters. To indicate the use of fixed filters, a flag and, if required, an index of the selected fixed filter are reported for each class. Even when a fixed filter is selected for a given class, the coefficients f(k, l) of the adaptive filter continue to be sent for that class and in such a case the coefficients of the filter that will be applied to the reconstructed image are the sum of both sets of coefficients.

The luminance component filtering process can be controlled at the CU level. The flag is set to indicate whether GALF is applied to the luma component. For the chroma component, whether GALF is applied or not is specified only at the image level.

3.1.4 Filtration process

On the decoder side, when GALF is enabled for a block, each sample R(i, j) within the block is filtered, resulting in a sample value R'(i, j) as shown below, where L denotes the filter length, f _m,n represents the filter coefficient and f(k, l) denotes the decoded filter coefficients.

(10)

3.1.5 Process of determining filter parameters on the encoder side

The general process of finding an encoder solution for GALF is shown in FIG. 3. For each CU's luminance samples, the encoder decides whether GALF is applied and the corresponding signaling flag is inserted into the fragment header. For chroma samples, the decision to apply a filter is made based on the image level rather than the CU level. Additionally, the GALF for the chrominance of the image is checked only when the GALF for the luma is enabled for the image.

4 Examples of adaptive contour filter based on geometry transformation for VVC

The current GALF design for VVC has the following major changes compared to that used in JEM:

1) The adaptive filter form has been removed. For the luma component, only a 7x7 filter shape is allowed, and a 5x5 filter shape is allowed for the chrominance component.

2) Temporal prediction of ALF parameters and prediction for fixed filters are both removed.

3) A one-bit flag is set for each CTU whether ALF is enabled or disabled.

4) The class index calculation is performed at the 4x4 level instead of 2x2. In addition, as proposed in JVET-L0147, a subsample Laplacian computation method is used to classify ALFs. More specifically, there is no need to calculate horizontal/vertical/45/135 degree diagonal gradients for each sample within a single block. Instead, 1:2 subsamples are used.

5 Examples of domain-based adaptive loop filter in AVS2

ALF is the last stage of loop filtration. There are two stages in this process. The first stage is obtaining filter coefficients. To prepare filter coefficients, the encoder classifies the reconstructed luminance component pixels into 16 regions and one set of filter coefficients is prepared for each category using Wiener-Hopf equations to minimize the mean squared error between the original frame and the reconstructed frame. To reduce redundancy between the 16 sets of filter coefficients, the encoder will adaptively couple them based on the distortion-rate performance characteristics. At its maximum, 16 different filter sets can be assigned to the luma component and only one to the chrominance component. The second step is to decide on a filter that contains both the frame level and the LCU level. The encoder first decides whether adaptive edge filtering is performed at the frame level. If the ALF frame level is enabled, then the encoder next decides whether ALF is performed at the LCU level.

5.1 Filter shape

The filter shape adopted in AVS-2 is a 7x7 cross shape superimposed on a 3x3 square shape, such as shown in FIG. 5, both for brightness and chrominance components. Each square in Fig. 5 corresponds to the count. Therefore, a total of 17 samples are used to obtain the filtered value for the sample at position C8. Considering the overhead of transmitting the coefficients, the symmetric point filter is used with only nine remaining coefficients, {C0, C1..., C8}, which reduces the number of filter coefficients by half, as well as the number of filtering multiplications. The symmetric point filter can also halve the calculations for one filtered sample, for example, only 9 multiplications and 14 additions for one filtered sample.

5.2 Adaptive region-based merging

To accommodate various encoding errors, AVS 2 adapts region-based adaptive contour multifilters for the luminance component. The luminance component is divided into 16 approximately equally sized core regions, with each core region aligned with the boundaries of the largest coding unit (LCU), as shown in FIG. 6, and one Wiener filter is obtained for each region. The more filters used, the more distortion is reduced, but the number of bits used to encode these coefficients increases with the number of filters. To achieve the best distortion-rate performance, these regions can be merged into fewer, larger regions that share the same filter coefficients. To simplify the fusion process, each region is assigned an index according to a modified Hilbert order based on correlations with previous images. Two regions with consecutive indices can be merged based on the cost of the distortion-rate metric.

Information about the conversion between areas must be reported to the decoder. In AVS 2, the number of core regions is used to represent the pooling results, and the filter coefficients are sequentially compressed according to their region order. For example, when {0, 1}, {2, 3, 4}, {5, 6, 7, 8, 9} and the left main regions are combined into one region, respectively, only three integers are encoded to represent this combined transformation , that is, 2, 3, 5.

5.3 Reporting side information

Numerous switch flags are also used. The sequence switch flag adaptive_loop_filter_enable is used to control whether an adaptive loop filter is applied to the entire sequence. The image switch flags picture_alf_enble[i] control whether ALF is applied to the corresponding i-th image component. The corresponding LCU level flags and filter coefficients for this chrominance component will only be transmitted if picture_alf_enble[i], is enabled. The LCU level flags, lcu_alf_enable [k], control whether ALF is enabled for the corresponding k-th LCU and whether they are interleaved in the fragment data. The decision about other adjustable level flags is based entirely on the distortion-rate cost. The high flexibility further makes ALF improve encoding efficiency much more significantly.

In some embodiments, there may be up to 16 sets of filter coefficients for the luminance component.

In some embodiments, one set of filter coefficients may be transmitted for each chrominance component (Cb and Cr).

6 GALF in VTM-4

According to VTM4.0, the adaptive loop filter filtering process is performed as follows:

where samples are input samples, is the filtered output sample (that is, the result of the filtering), and w(i, j) denotes the filter coefficients. In practice, VTM4.0 does this by using integer arithmetic for fixed-point precision calculations:

where L denotes the filter length, and where w(i, j) are the filter coefficients at a fixed precision point.

7 Filtration with nonlinear adaptive loop filtering (ALF)

7.1 Reformulation of filtering

Equation (11) can be reformulated without affecting coding efficiency into the following expression:

Here, w(i, j) are the same filter coefficients as in equation (11) [except w(0, 0) which is equal to 1 in equation (13), while in equation (11) it equals .

7.2 Modified filter

Using these filter formulas (13) above, we can easily introduce nonlinearity to make ALFA more efficient by using a simple limiting function to reduce the influence of neighboring sample values (when they are too different from the current value (I(x, y)) of the filtered sample.

In this proposal, the ALFA filter is modified as follows:

Here K(d, b) = min(b, max(-b, d)) is the constraint function, and k(i, j) are the constraint parameters, which depend on the filter coefficient (i, j). The encoder performs optimization to discover the best value of k(i, j).

In the JVET-N0242 implementation, the constraint parameters k(i, j) are defined for each ALFA filter, one constraint value is reported for each filter coefficient. This means that up to 12 clipping values can be reported in a bitstream for each luma filter, and up to 6 clipping values can be reported for a chrominance filter.

To limit signaling overhead and encoder complexity, we limit the evaluation of constraint values to a small set of possible values. According to the proposal, we only use 4 fixed values, which are the same for the tiling groups INTER and INTRA.

Because the local difference variance is often higher for brightness (Luma) than for chroma (Chroma), we use two different sets for the Luma and Chroma filters. We also introduce a maximum sample value (here 1024 for 10-bit bit depth) in each set so that the limit can be disabled if it is not required.

The sets of cutoff values used in the JVET-N0242 tests are shown in Table 2. The 4 values were selected by roughly equally splitting in the logarithmic domain the full range of sample values (encoded at 10 bits) for Luma, and the range from 4 to 1024 for Chroma.

More precisely, the table of constraint values for Luma was obtained using the following formula:

Similarly, tables of limit values for Chroma are obtained according to the following formula:

table 2

Allowed limit values

Group of mosaics INTRA/INTER BRIGHTNESS { 1024, 181, 32, 6 } COLORITY { 1024, 161, 25, 4 }

The selected constraint values are encoded in the “alf_data” syntax element using the Golomb encoding scheme corresponding to the constraint value index in Table 2 above. This encoding scheme is the same as the encoding scheme for the filter index.

8 In-loop reshaping (ILR) in JVET-M0427

In-loop reshaping (ILR) is also known as Luma Mapping with Chroma Scaling (LMCS).

The basic idea of contour reshaping (ILR) is to transform the initial (in the first region) signal (prediction/reconstruction signal) into a second region (shape reconstruction region).

The contour shaper for luminance is implemented as a pair of look-up tables (LUTs), but only one of the two LUTs must be reported, since the other can be calculated from the reported LUT. Each LUT is a one-dimensional, 10-bit, 1024-input lookup table (1D-LUT). One LUT is a forward LUT, FwdLUT, which converts the input luminance code values Y _i to modified values: Y _r = FwdLUT[Y _i ]. The other LUT is the inverse LUT, InvLUT, which converts the modified Y _r code values into $$\stackrel{⌢}{A}$$ : $${\stackrel{⌢}{Y}}_i$$ = InvLUT[Y _r ]. ( $${\stackrel{⌢}{Y}}_i$$ represents the reconstructed values of Y _i ).

8.1 PWL model

Conceptually, the piece-wise linear (PWL) model works as follows:

Let x1, x2 be two input turning points and y1, y2 be their corresponding output turning points for one piece. The output value y for any input value x between x1 and x2 can be interpolated by the following equation:

y = ((y2-y1) / (x2-x1)) * (x-x1) + y1

In a fixed point implementation, the equation can be rewritten as:

y = ((m * x + 2FP_PREC-1)>> FP_PREC) + c

Here m is a scalar, c is the offset and FP_PREC is a constant value indicating the precision.

Note that in the CE-12 software, the PWL model is used to precompute the 1024-input FwdLUT and InvLUT lookup tables; but the PWL model also allows implementations to compute identical transform values continuously, without first computing the LUT.

8.2 Test CE12-2 at the 4th VVC meeting

8.2.1 Restoring the Luma shape

Luminance Contour Shape Reconstruction Test 2 (i.e., CE12-2 in the proposal) provides a processing sequence with less complexity, which also eliminates the decoding delay for intra-frame block prediction in inter-frame fragment reconstruction. Intra-frame prediction is performed in the reconstructed shape region for both inter- and intra-frame prediction fragments.

Intra-frame prediction is always performed in the reshaping region, regardless of the fragment type. With this design, intra-frame prediction can start immediately after the previous TU reconstruction is done. This design can also provide a unified process for intra-frame mode rather than being fragment dependent. In fig. 7 is a flowchart of the mode-based decoding process of CE12-2.

The CE12-2 also tests 16-piece piecewise linear (PWL) models for luma and chroma, scaling the remainder instead of using the 32-piece PWL models from the CE12-1.

Inter-frame reconstruction of fragments using the contour shape restoration device in CE12-2 (lighter shaded blocks indicate the signal in the reshaping region: residual brightness; intra-frame predicted brightness and intra-frame reconstructed brightness).

8.2.2 Scaling the luminance-dependent chrominance residual

Scaling the luminance-dependent chrominance residual is a multiplicative process performed with fixed-point integer operation. Chroma residual scaling compensates for the interaction of the luma signal with the chrominance signal. Chroma residual scaling is applied at the TU level. More specifically, the following applies:

- For intra-frame prediction, the reconstructed luminance is averaged.

- For inter-frame prediction, the luminance prediction is averaged.

The average value is used to identify the index in the PWL model. The index identifies the scale factor cScaleInv. The residual color is multiplied by this factor.

Note that the chroma scaling factor is calculated from the predicted luminance values from the forward transform, and not from the reconstructed luminance values.

8.2.3 ILR side information message

The parameters are (currently) sent in the tile group header (similar to ALF). They reportedly take 40-100 bits. The following specification is based on version 9 of JVET-L1001. The added syntax is highlighted below in italic font.

The following semantics are added to the RBSP semantics of the General sequence parameter set:

sps_reshaper_enabled_flag equal to 1 indicates that the reshaper shaper is used in the coded video sequence (CVS). sps_reshaper_enabled_flag equal to 0 indicates that the reshaper reshaper is not used in CVS.

The following semantics are added to the tiled group header syntax

tile_group_reshaper_model_present_flag equal to 1 indicates that tile_group_reshaper_model() is present in the header is not present in the tile group header. tile_group_reshaper_model_present_flag equal to 0 indicates that tile_group_reshaper_model() is not present in the tile group header. When tile_group_reshaper_model_present_flag is not present, it is assumed to be 0.

tile_group_reshaper_enabled_flag equal to 1 indicates that the reshaper reshaper is enabled for the current tile group. tile_group_reshaper_enabled_flag equal to 0 indicates that the reshaper reshaper is not enabled for the current tile group. When tile_group_reshaper_enable_flag is not present, it is assumed to be 0.

tile_group_reshaper_chroma_residual_scale_flag equal to 1 indicates that residual chroma scaling is enabled for the current tile group. tile_group_reshaper_chroma_residual_scale_flag equal to 0 indicates that residual chroma scaling is not enabled for the current tile group. When tile_group_reshaper_chroma_residual_scale_flag is not present, it is assumed to be 0.

Add tile_group_reshaper_model() syntax

reshape_model_min_bin_idx specifies the index of the minimum bin (chunk) that should be used in the process of constructing the reshape shaper. The value of reshape_model_min_bin_idx must be in the range from 0 to MaxBinIdx, inclusive. The MaxBinIdx value should be 15.

reshape_model_delta_max_bin_idx specifies the index of the maximum allowed bin (chunk) MaxBinIdx minus the maximum bin index that should be used during the construction of the shape recovery shaper. The reshape_model_max_bin_idx value is set to MaxBinIdx – reshape_model_delta_max_bin_idx.

reshaper_model_bin_delta_abs_cw_prec_minus1 plus 1 specifies the number of bits used to represent the reshape_model_bin_delta_abs_CW[ i ] syntax.

reshape_model_bin_delta_abs_CW[i] specifies the absolute value of the delta codeword for the i-th bin.

reshaper_model_bin_delta_sign_CW_flag[i] specifies the sign of reshape_model_bin_delta_abs_CW[i] as follows:

– If reshape_model_bin_delta_sign_CW_flag[ i ] is equal to 0, the corresponding variable RspDeltaCW[ i ] has a positive value.

– Otherwise, ( reshape_model_bin_delta_sign_CW_flag[ i ] is not equal to 0 ), the corresponding variable RspDeltaCW[ i ] has a negative value.

When reshape_model_bin_delta_sign_CW_flag[ i ] is not present, it is assumed to be 0.

The variable RspDeltaCW[ i ] is equal to (1 2*reshape_model_bin_delta_sign_CW [ i ]) * reshape_model_bin_delta_abs_CW [ i ];

The variable RspCW[ i ] is obtained in the following steps:

The OrgCW variable is set to (1 << BitDepth _Y ) / ( MaxBinIdx + 1 ).

– If reshaper_model_min_bin_idx <= i <= reshaper_model_max_bin_idx

RspCW[i] = OrgCW + RspDeltaCW[i].

– Otherwise, RspCW[ i ] = 0.

The value of RspCW[i] must be in the range from 32 to 2 * OrgCW – 1 if the BitDepth _Y I value is 10.

InputPivot[ i ] variables with i in the range 0 to MaxBinIdx + 1, inclusive, are obtained as follows:

InputPivot[i] = i * OrgCW

The variable ReshapePivot[ i ] with i in the range from 0 to MaxBinIdx + 1, inclusive, the variables ScaleCoef[ i ] and InvScaleCoeff[ i ] with i in the range from 0 to MaxBinIdx, inclusive, are obtained as follows:

The variable ChromaScaleCoef[ i ] with i in the range 0 to MaxBinIdx , inclusive, is obtained as follows:

ChromaResidualScaleLut[64] = {16384, 16384, 16384, 16384, 16384, 16384, 16384, 8192, 8192, 8192, 8192, 5461, 5461, 5461, 5461, 4096, 4096 , 4096, 4096, 3277, 3277, 3277, 3277, 2731, 2731, 2731, 2731, 2341, 2341, 2341, 2048, 2048, 2048, 1820, 1820, 1820, 1638, 1638, 1638, 1638, 1489, 1489, 148 9, 1489, 1365, 1365, 1365, 1365, 1260, 1260, 1260, 1260, 1170, 1170, 1170, 1170, 1092, 1092, 1092, 1092, 1024, 1024, 1024, 1024};

shiftC = 11

– if ( RspCW[ i ] == 0 )

ChromaScaleCoef[ i ] = (1 << shiftC) – Otherwise, (RspCW[ i ] != 0), ChromaScaleCoef[ i ] = ChromaResidualScaleLut[RspCW[ i ] >> 1]

8.2.4 Using ILR

On the encoder side, each image (or tile group) is first converted into a reshaping region. And the entire encoding process is done in the reframing area. For intra-frame prediction, the adjacent block is in the reshaping region; For inter-frame prediction, reference blocks (formed from the original region from the decoded image buffer) are first converted into a reshaping region. The remainder is then generated and encoded into a bitstream.

After the entire image (tile group) has finished encoding/decoding, the samples in the reshaping region are converted to the original region and then the deblocking filter and other filters are applied.

Direct conversion to a prediction signal is prohibited in the following cases:

- The current block is intraframe encoded

-The current block is encoded as CPR (current picture referencing, also called intra block copy, IBC)

-The current block is encoded as combined inter-intra mode (CIIP), and direct reframing is prohibited for the intra-predictive block.

9 Disadvantages of existing implementations

The Nonlinear ALF (NLALF) design in JVET-N0242 has the following issues:

(1) It was designed for the 4:2:0 color format. For the 4:4:4 color format, the luminance and chrominance components may have similar meanings. How best to use NLALF is unknown.

(2) The limit values are designed for the 10-bit case. How to define NLALF for other bit depths has not yet been studied.

(3) The interaction of contour reshaping method and NLALF has not been studied.

10 Examples of Improvements to Nonlinear Adaptive Loop Filtering

Embodiments of the technology disclosed here overcome the shortcomings of existing implementations, thereby providing video encoding with higher encoding efficiency. Nonlinear adaptive contour filtering based on the disclosed technology can improve both current and future video coding standards and is explained in the following examples described for various implementations. The examples of disclosed technology presented below explain general concepts and are not intended to be interpreted as limiting. An example, unless explicitly stated otherwise, may combine various features described in these examples.

1. It is assumed that parameters (eg, constraint parameters defined in Table 2) used in NLALF may depend on the encoded information.

a. It is assumed that the parameters (eg, the constraint parameters defined in Table 2) used in NLALF may depend on the time level index/delay check flag low/reference pictures.

2. Multiple sets of NLALF parameters may be defined or reported.

a. Alternatively, further, when multiple NLALF parameter sets are reported, they may be reported in a data block such as an Adaptation Parameter Set (APS)/tile group header/video data blocks.

b. In one example, NLALF parameters are reported in a predictable manner.

i. For example, one set of NLALF parameters reported in one data block (such as an APS or tile or tile) is predicted by another set of NLALF parameters reported in the same data block.

ii. For example, one set of NLALF parameters reported in one data block (such as an APS or tile or tile) is predicted by another set of NLALF parameters reported in another data block.

3. It is assumed that the parameters (eg, the constraint parameters defined in Table 2) used in NLALF may depend on the bit depth of the reconstructed samples before NLALF is applied.

a. Alternatively, it is contemplated that the parameters (eg, the limiting parameters defined in Table 2) used in NLALF may depend on the input bit depth of samples before encoding/decoding.

b. In one example, the parameters for a given bit depth may be derived from those that were assigned to another bit depth.

i. In one example, shift operations corresponding to bit depth may be applied to obtain parameters for a given bit depth.

4. It is assumed that the parameters (eg, the constraint parameters defined in Table 2) used in NLALF may depend on the color format of the presentation.

a. In one example, for the RGB case, there is a parameter with the same index for the G chrominance component and for the B/R chrominance components.

5. It is assumed that the parameters (eg, the constraint parameters defined in Table 2) used in NLALF may depend on whether the contour reshaping (ILR) method is used.

a. In one example, the parameters may differ when ILR is enabled or disabled.

6. It is expected to remember filter parameters (such as filter coefficients) and NLALF parameters (such as limit parameters) together.

a. In one example, they may both be stored in the APS.

b. In one example, when one video data unit (eg, CTU/area/tile group) uses utilization filter coefficients associated with one APS, the associated NLALF parameters may also be used.

c. Alternatively, for encoding/decoding one block of video data (eg, CTU/region/tile), when prediction from filter coefficients associated with one APS is enabled, the associated NLALF parameters can also be used to predict NLALF parameters for one block of video data from that the same APS.

7. How to control NLALF for chrominance color components may depend on the color format.

a. In one example, for a given color format (such as 4:4:4), two color components may use different NLALF parameters.

8. It is intended that the limit in ALF can be turned on or off at the sequence level, image level, fragment level, tile group level, tile level, CTU level, CU level or block level.

a. For example, whether to include a constraint in the ALF may be communicated to the decoder, as in the SP, PPS, tile header, tile group header, tile, CTU, CU, or block.

The examples described above may be included in the context of the methods described below, for example, methods 810-840, which may be implemented in a video decoder or video encoder.

In fig. 8A is a flowchart of an exemplary method for processing video data. According to method 810, at step 812, a video block of video is encoded as an encoded video block. Method 810 further comprises step 813 of generating reconstruction samples from the encoded video block. Method 810 further comprises a step 814 of performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block samples. Method 810 further comprises step 815 in which a nonlinear adaptive loop filter is applied to the output of the limiting operation. Method 810 further comprises step 816 of generating an encoded representation of the video using the encoded video block.

In fig. 8B is a flowchart of an exemplary method for processing video data. Method 820 includes step 822, which parses an encoded video representation for an encoded video block representing the video video block. Method 820 further comprises step 823, which generates video block reconstruction samples from the encoded video block. Method 820 includes step 824 of performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the video block bit depth. Method 820 further comprises step 825 of applying a nonlinear adaptive contour filter to the output of the constraint operation to generate a final decoded video block.

In fig. 8C is a flowchart of an exemplary method for processing video data. Method 830 includes step 832, which performs a conversion between an encoded representation of a video containing one or more video regions and a video. Method 830 further comprises step 834, which determines a constraint parameter for filtering the reconstruction of a video region video block using a nonlinear adaptive edge filter. In some implementations, the determination is based on encoded video and/or video area and/or video block information. In some implementations, the constraint parameter is a function of the presentation color format. In some implementations, the constraint parameter depends on whether contour reshaping (ILR) is applied to reconstruct the video block based on the representation of the video block in the first region and the second region and/or to determine the scale of the chroma residual of the chroma video block.

In fig. 9 is a flowchart of the video data processing method. Method 840 includes performing a conversion between an encoded representation of a video comprising one or more video regions and a video. In some implementations, the encoded representation contains first side information that provides a constraint parameter for filtering the reconstruction of a video domain video block using a nonlinear adaptive edge filter, and the first side information is reported along with second side information indicating filter coefficients used in the nonlinear adaptive edge filter. In some implementations, the encoded representation contains side information indicating multiple parameter constraint sets for filtering the reconstruction of a video domain video block using a nonlinear adaptive edge filter. In some implementations, the encoded representation contains side information that provides one or more constraint parameters for filtering the reconstruction of a video domain chroma video block using a nonlinear adaptive edge filter in which one or more constraint parameters depend on the color format. In some implementations, the encoded representation contains side information that provides a constraint parameter for filtering the reconstruction of a video domain video block using an adaptive contour filter, wherein the implementation comprises generating a filtered video block by applying a constraint operation to the sample differences at the video domain level.

11 Exemplary implementations of the disclosed technology

In fig. 10A is a block diagram of a video processing apparatus 900. Apparatus 900 may be used to implement one or more of the methods described herein. The device 900 may be implemented in a smartphone, tablet, computer, Internet of Things (IoT) receiver, and so on. Device 900 may include one or more processors 902, one or more memories 904, and video processing hardware 906. Processor(s) 902 may be configured to implement one or more of the methods (including, but not limited to, method 800) described herein. Memory(s) 904 may be used to store data and control program used to implement the methods and techniques described herein. Video processing hardware 906 may be used to implement in hardware circuits some of the methods described herein.

In fig. 10B is another example block diagram of a video processing system in which the disclosed technologies may be implemented. In fig. 10B is a block diagram showing an example video processing system 4100 in which various technologies disclosed herein may be implemented. Various implementations may include some or all of the components of the system 4100. The system 4100 may include an input 4102 for receiving video content. Video content may be received in a raw or uncompressed format, such as 8- or 10-bit multi-pixel values, or may be received in a compressed or encoded format. Input 4102 may be a network interface, a peripheral bus interface, or a storage device interface. Examples of a network interface include wired interfaces such as Ethernet, passive optical network (PON), etc., and wireless partition interfaces such as Wi-Fi or cellular interfaces.

System 4100 may include an encoding component 4104 that can implement various encodings or encoding methods described herein. The encoding component 4104 may downgrade the average video bit rate from the input 4102 to the output of the encoding component 4104 to create an encoded representation of the video. Encoding technologies are therefore sometimes called video compression or video transcoding technologies. The output of encoding component 4104 may be either stored or transmitted over an attached communication connection, as represented by component 4106. The stored or transmitted (or encoded) bitstream representation received at input 4102 may be used by component 4108 to generate pixel values or display video that is sent to display interface 4110. The process of generating user-viewable video from a bitstream representation is sometimes called video decompression. Additionally, although some video processing operations are referred to as "encoding" operations or tools, it should be understood that the encoding tools or operations are used in the encoder, and the corresponding decoding tools or operations, which produce results inverse to the encoding, must be performed by the decoder.

Examples of a peripheral bus interface or display interface may include a universal serial bus (USB) or a high definition multimedia interface (HDMI) or Displayport, and so on. Examples of storage device interfaces include SATA (serial advanced technology attachment), PCI, IDE, etc. The technologies described in this document can be implemented in various electronic devices, such as mobile phones, laptops, smartphones, or other devices capable of perform digital data processing and/or video display.

Some embodiments of the disclosed technology involve deciding or determining permission for a video processing tool or mode. In an example where a video processing tool or mode is enabled, the encoder will use or implement the tool or mode when processing a block of video, but may not necessarily modify the resulting bitstream based on the use of the tool or mode. That is, the conversion from a video block to a video bitstream representation will use the video processing tool or mode when permitted based on the decision or determination made. In another example, when the video processing tool or mode is enabled, the decoder will process the bitstream knowing that the bitstream has been modified based on the video processing tool or mode. That is, the conversion from a video bitstream representation to a video block will be performed using a video processing tool or mode that has been enabled based on the decision or determination.

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

As used herein, the term "video processing" may refer to video encoding, video decoding, video compression, or video decompression. For example, video compression algorithms may be applied during conversion from a video pixel representation to a corresponding bitstream representation or vice versa. The bitstream representation of the current video block may, for example, correspond to bits that are co-located or scattered at different locations within the bitstream, as determined by the syntax. For example, a macroblock may be encoded in terms of the residual values of the converted and encoded errors, as well as the use of bits in headers and other fields in the bitstream.

In some embodiments, video encoding methods may be implemented using an apparatus that is implemented on a hardware platform as described with reference to FIG. 10A or 10B.

Various technologies and embodiments may be described using the following paragraph-based format.

The first set of clauses describes the features and approaches of the disclosed technologies listed in the previous section.

1. A method for processing video data, comprising the steps of: determining, based on the encoded information of the current video block, a set of parameters of the current video block; and reconstructing, based on performing a nonlinear filtering operation using a set of parameters, the current block based on the corresponding bitstream representation.

2. The method of claim 1, wherein the nonlinear filtering operation comprises nonlinear adaptive loop filtering.

3. The method according to claim 1 or 2, wherein the set of parameters contains at least one constraint value for the luma component or the chrominance component of the current video block.

4. The method of claim 3, wherein the nonlinear filtering operation is based on a color format of the chrominance component.

5. Method according to any one of paragraphs. 1-3, wherein the encoded information contains a temporary level index, a low delay check flag, or one or more reference pictures.

6. Method according to any one of paragraphs. 1-3, in which the encoded information contains the bit depth of the reconstructed samples obtained before the nonlinear filtering operation.

7. Method according to any one of paragraphs. 1-3, in which the encoded information includes a color representation format.

8. Method according to any one of paragraphs. 1-3, in which the encoded information contains an indication of the use of the contour reshaping method (in-loop reshaping, ILR).

9. Method according to any one of paragraphs. 1-3, wherein the corresponding bitstream representation contains multiple parameter sets that contain a particular set of parameters, and wherein the multiple parameter sets are communicated in an Adaptation Parameter Set (APS), a tile group header, or one or more video data blocks.

10. Method according to any one of paragraphs. 1-3, wherein the corresponding bitstream representation comprises an adaptation parameter set (APS) that contains a set of parameters and one or more filter coefficients associated with the nonlinear filtering operation.

11. The method of claim 1 or 2, wherein the parameter set contains one or more constraint values and wherein the nonlinear filtering operation is performed at the sequence level, the image level, the fragment level, the tile group level, the mosaic level, the coding tree block level (coding tree unit, CTU), coding unit (CU) level, or block level.

12. A device in a video system containing a processor and long-term storage memory with commands contained therein, in which the commands, after they are executed by the processor, cause the processor to implement the method according to any one of claims. 1-11.

13. A computer program product stored on a computer-readable storage medium, wherein the computer program product contains a control program for performing the method according to any one of claims. 1-11.

The second set of paragraphs describes some of the features and approaches of the disclosed technologies listed in the previous section, including, for example, exemplary implementations 1 and 3-5.

1. A method for processing video data, comprising the steps of: encoding a video video block as an encoded video block; generating reconstruction samples from the encoded video block; performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block samples; applying a nonlinear adaptive loop filter to the output result of the constraint operation; and generating a coded representation of the video using the coded video block.

2. The method of claim 1, wherein the constraint index is reported in an encoded representation.

3. A method for processing video data, comprising the steps of: parsing an encoded video representation for an encoded video block representing a video video block; generating video block reconstruction samples from the encoded video block; performing a constraint operation on the reconstruction samples, wherein the constraint parameter used in the constraint operation is a function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block; and applying a nonlinear adaptive contour filter to the output result of the constraint operation to generate a final decoded video block.

4. The method of claim 3, wherein the constraint index is determined based on at least a field in the encoded representation.

5. The method of claim 3, wherein the constraint index is determined using a predetermined rule.

6. The method of claim 1 or 3, wherein the function of the constraint index and the bit depth of the reconstruction samples or the bit depth of the video block is such that the function returns different values for a given constraint index value based on the bit depth of the reconstruction samples or the bit depth of the video block.

7. The method of claim 1 or 3, wherein the conversion between the constraint index and the constraint parameter depends on the bit depth of the reconstruction sample or the bit depth of the video block.

8. The method of claim 1 or 3, wherein a first constraint value corresponding to a first constraint index for a given bit depth is obtained based on a second constraint value corresponding to a second constraint index for a different bit depth.

9. The method of claim 8, wherein an offset operation using a different bit depth is applied to obtain a constraint parameter for a given bit depth.

10. Method according to any one of paragraphs. 1-9, in which the encoded representation contains a constraint parameter that controls an upper or lower bound on two sample differences used in the nonlinear adaptive loop filter.

11. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video areas and a video; and determining a constraint parameter for filtering the reconstruction of the video block of the video region using a nonlinear adaptive contour filter, and wherein the determination is based on encoded information of the video and/or video region and/or video block.

12. The method according to claim 11, wherein the encoded information contains a temporary level index.

13. The method of claim 11, wherein the encoded information includes a low delay check flag.

14. The method of claim 11, wherein the encoded information comprises one or more reference images.

15. Method according to any one of paragraphs. 11-14, in which the video area contains a video image.

16. Method according to any one of paragraphs. 11-14, in which the video block contains an encoding block.

17. Method according to any one of paragraphs. 11-16, in which the limit parameter controls the upper or lower bound of two sample differences used in the nonlinear adaptive loop filter.

18. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video regions and a video; and determining a constraint parameter for filtering the reconstruction of the video domain video block using a nonlinear adaptive edge filter, and wherein the constraint parameter is a function of the color format of the presentation.

19. The method of claim 18, wherein for the RGB color format, the constraint parameter has the same index for the green color component and for the blue or red color component.

20. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video regions and a video; and determining a constraint parameter for filtering the video block reconstruction of the video region using a nonlinear adaptive edge filter, and wherein the constraint parameter depends on whether in-loop reshaping (ILR) is applied to reconstruct the video block based on the representation of the video block in the first region and in the second region and/or on the scaling of the remaining chrominance of the chrominance video block.

21. Method according to any one of paragraphs. 1-21, in which the limit parameter corresponds to the limit value for the luma component or the chrominance component of the video block.

22. Method according to any one of paragraphs. 1-21, wherein the method further comprises generating a filtered video block during transformation by applying a nonlinear adaptive contour filter to the reconstruction of the video block, and using the filtered video block to determine a prediction of another video block of video.

23. Method according to any one of paragraphs. 1-22, wherein performing the transformation comprises generating an encoded representation from the video.

24. Method according to any one of paragraphs. 1-22, wherein performing the transformation comprises generating video from the encoded representation.

25. A device in a video system containing a processor and long-term storage memory with commands written therein, in which the commands, after they are executed by the processor, cause the processor to implement the method according to any one of claims. 1-24.

26. A computer program product stored on a computer readable storage medium, wherein the computer program product comprises a control program for performing the method of any one of claims. 1-24.

The third set of paragraphs describes some of the features and approaches of the disclosed technologies listed in the previous section, including, for example, example implementations 2 and 6-8.

1. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video regions and a video, in which the encoded representation contains first side information that provides a constraint parameter for filtering the reconstruction of a video block of the video region using nonlinear adaptive loop filter; wherein the first side information is reported together with the second side information indicating filter coefficients used in the nonlinear adaptive loop filter.

2. The method of claim 1, wherein the first side information and the second side information are reported in the same set of adaptation parameters.

3. The method of claim 1, wherein, in the case where at least some of the filter coefficients associated with the set of adaptation parameters are used by the video data block, the constraint parameter associated with the set of adaptation parameters is also used by the video data block.

4. The method of claim 1, wherein when prediction of at least some of the filter coefficients associated with the set of adaptation parameters is enabled to transform a block of video data, the parameter associated with the set of adaptation parameters is used to predict another parameter for another block of video data from the set of adaptation parameters.

5. The method of claim 3 or 4, wherein the video data block is a coding tree block, a video region, or a tile group.

6. Method according to any one of paragraphs. 1-5, in which the parameter corresponds to the limit value for the luma component or the chrominance component of the video block.

7. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video regions and a video in which the encoded representation contains side information indicating multiple sets of constraint parameters for filtering the reconstruction of a video block of the video region using nonlinear adaptive contour filter.

8. The method of claim 7, wherein the side information comprises multiple sets of constraint parameters.

9. The method of claim 7, wherein the multiple sets of constraint parameters are known to the encoder and decoder, and the side information comprises an index into one or more of the multiple sets of constraint parameters.

10. The method of claim 7, wherein the multiple sets of constraint parameters are included in the video data block or in a video block header.

11. The method of claim 10, wherein the video data block comprises a set of adaptation parameters, a tile group or a fragment.

12. The method of claim 8, wherein one of the set of multiple constraint parameters reported in the data block is predicted by another set of constraint parameters reported in the data block.

13. The method of claim 7, wherein one set of the plurality of sets of constraint parameters reported in the data block is predicted by another set of constraint parameters reported in the other data block.

14. A method for processing video data, comprising the steps of: performing a conversion between an encoded representation of a video containing one or more video areas and a video; wherein the encoded representation contains side information that provides one or more constraint parameters for filtering the reconstruction of a video domain chroma video block using a nonlinear adaptive edge filter, wherein the one or more constraint parameters depend on the color format.

15. The method of claim 14, wherein for a particular color format, the two chromaticity components use different limiting parameters.

16. The method of claim 15, wherein the specific color format is 4:4:4.

17. Method according to any one of paragraphs. 1-16, wherein the method further comprises generating a filtered video block during transformation, applying a nonlinear adaptive contour filter to the reconstruction of the video block, and using the filtered video block to determine a prediction of another video block of video.

18. A method for processing video data, comprising the steps of: performing transformations between an encoded representation of a video containing one or more video regions and a video in which the encoded representation contains side information providing a constraint parameter for filtering the reconstruction of a video block of the video region using an adaptive edge filter, wherein execution comprises generating a filtered video block by applying a constraint operation to sample the differences at the video region level.

19. The method of claim 18, wherein the video region level is a sequence level, an image level, a tile level, a tile group level, a tile level, a coding tree block level, a coding block level, or a block level.

20. The method of claim 18, wherein the indication to enable constraint operations is communicated in a sequence parameter set (SPS), picture parameter set (PPS), fragment header, tile group header, tile, coding tree block , coding block or block.

21. Method according to any one of paragraphs. 1-20, in which the video area is a video image.

22. Method according to any one of paragraphs. 1-20, wherein the video block is a coding block or a transform block or a fragment or a coding tree or a coding tree line.

23. Method according to any one of paragraphs. 1-22, wherein performing the transformation comprises generating an encoded representation from the current block.

24. Method according to any one of paragraphs. 1-22, wherein performing the transformation comprises generating a current block from the encoded representation.

25. A device as part of a video system containing a processor and long-term storage memory with commands stored on it, in which the commands, when executed by the processor, cause the processor to implement the method according to any one of claims. 1-24.

26. A computer program product stored on a computer readable storage medium, wherein the computer program product comprises a control program for performing the method of any one of claims. 1-24.

From the foregoing, it should be understood that specific embodiments of the technology disclosed herein have been described for purposes of illustration, but various changes may be made thereto without departing from the scope of the invention. Accordingly, the technology disclosed herein is not limited beyond the appended claims.

Implementations of the subject matter and functional operations described in this patent document may be implemented in various systems, digital electronic circuits, or software, firmware, or hardware, including the structures disclosed herein and their structural equivalents. or a combination of one or more of them. Implementations of the subject matter described herein may be embodied as one or more computer program products, that is, as one or more computer program instruction modules encoded on a physical and computer-readable storage medium for executing or controlling the operation of a data processing device. The computer-readable medium may be a computer-readable storage device, a computer-readable storage medium, a composition of substances carrying a propagated computer-readable signal, or a combination of one or more of these. The term "data processing unit" or "data processing device" covers all equipment, devices and machines for processing data, including, for example, a programmable processor, a computer or multiple processors or computers. The device may contain, in addition to hardware, code that creates an execution environment for a computer program, such as code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of these.

A computer program (also known as a program, software, application, script, or code) can be written in any form of a programming language, including compiled or interpreted languages, and can be deployed in any form, including as a stand-alone program or as a module, component , subroutine, or other block suitable for use in a computer environment. A computer program does not necessarily correspond to a file on a file system. A program may be stored in a portion of a file that stores other programs or data (for example, in one or more scripts stored in a markup language document), in a single file assigned to said program, or in multiple coordinated files (for example, files storing one or more modules, subroutines or pieces of code). A computer program can be deployed to run on a single computer or on multiple computers that are located in one location or distributed in multiple locations and connected by a communications system.

The processes and logical flows presented in this description may be executed by one or more programmable processors executing one or more computer programs to perform functions that operate on input data and generate output data. Processes and logic flows may also be executed and the device may also be implemented as a special purpose logic circuit, such as an FPGA (field programmable logic integrated circuit) or ASIC (application specific integrated circuit).

Processors suitable for executing a computer program include, for example, general-purpose and special-purpose microprocessors and any one or more processors of any kind of digital computer. Typically, the processor must accept instructions and data from read-only memory or RAM, or both. The essential elements of a computer are a processor for executing instructions and one or more storage devices for storing instructions and data. Typically, the computer will also comprise or be operatively coupled to receive data or transmit data, or both, to one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks. However, the computer does not necessarily have to have such devices. A computer-readable medium suitable for storing computer program instructions and data includes any form of non-volatile memory, storage media and storage devices, including, for example, semiconductor memory devices, for example. EPROM, EEPROM and flash memory devices. The processor and memory can be supplemented or included in special-purpose logic circuits.

It is understood that the description together with the drawings is to be considered as an example only. The singular as used herein will also include the plural unless the context clearly indicates otherwise. Additionally, the use of "or" implies the use of "and/or" unless the context clearly indicates otherwise.

Although this patent document contains many specific features, they should not be considered as limitations on the scope of protection of any invention or what may be claimed, but rather as descriptions of features that may be specific to particular embodiments of particular inventions. Certain features that are described in this patent document in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment may also be implemented in multiple embodiments separately or in any suitable sub-combination. In addition, although features may be described above as operating in some combination and even initially claimed as such, one or more features from a claimed combination may in some cases be extracted from the combination and the claimed combination may be directed into a subcombination or variation of a subcombination.

Likewise, although operations are shown in the drawings in a particular order, this should not be understood to require that such operations be performed in the particular order shown or in a sequential order or that all operations shown must be performed to achieve the desired results. Moreover, the separation of various system components in the embodiments described in this patent document should not be understood to require such separation in all embodiments.

Only a few implementations and examples have been described and other implementations, improvements and variations may be made based on what is described and shown in this patent document.

Claims (40)

1. A method for processing video data, comprising the steps of: determining that a nonlinear adaptive contour filtering operation is applied to the current video region of the video, wherein the current video region is a coding tree block; obtaining at least one first filtering index for the current video area and obtaining one or more first filtering parameters based on the at least one first filtering index; obtaining one or more first constraint parameters from the set of constraint parameters based on said at least one first filtering index; perform a limiting operation that is part of a nonlinear adaptive contour filtering operation based on said one or more first limiting parameters, wherein said one or more first limiting parameters are used to limit differences between reference sample values of the current sample value of the current video area and the current sample value before applying said one or more first filtering parameters; And performing a conversion between the current video region and the video bitstream based on a nonlinear adaptive contour filtering operation; wherein a set of constraint parameters is created based on a bit depth and a constraint index based on a given table, wherein in a given table, the value of one constraint parameter corresponding to the first constraint index for a given bit depth is obtained based on the value of another constraint parameter corresponding to the first constraint index for different bit depth. 2. The method of claim 1, wherein a shift operation is used to obtain constraint parameter values from the constraint parameter set. 3. The method of claim 1, wherein the constraint index is associated with a field in the bitstream. 4. The method of claim 1, wherein the constraint index is determined using a predetermined rule. 5. The method according to claim 1, in which the set of constraint parameters uses different values of the constraint parameters for different bit depths for a given constraint index value. 6. The method according to claim 1, in which in a given table the value of one constraint parameter is obtained based on the application of a shift operation to the value of another constraint parameter. 7. The method of claim 1, wherein said at least one first filter index is obtained based on a plurality of sample differences in different directions. 8. The method of claim 7, wherein the current video region is divided into a plurality of video regions of size M*M, and a plurality of sample differences in different directions are obtained for each video subregion of size M*M, and where M is 2 or 4. 9. The method of claim 8, wherein a plurality of sample differences in different directions is obtained based on a subsampling frequency of 1:N, where N is greater than 1. 10. The method of claim 1, wherein said one or more first filter parameters and said one or more first constraint parameters are obtained based on the same adaptation parameter set identification. 11. The method according to claim 1, wherein the conversion step encodes the current video area into a bitstream. 12. The method according to claim 1, wherein the conversion step decodes the current video region from the bit stream. 13. A video data processing device containing a processor and long-term user memory with commands, wherein the commands, when executed by the processor, cause the processor to execute: determining that a nonlinear adaptive contour filtering operation is applied to the current video region of the video, wherein the current video region is a coding tree block; obtaining at least one first filtering index for the current video area and obtaining one or more first filtering parameters based on the at least one first filtering index; obtaining one or more first constraint parameters from the set of constraint parameters based on said at least one first filtering index, performing a limiting operation that is part of a nonlinear adaptive contour filtering operation based on said one or more first limiting parameters, wherein said one or more first limiting parameters are used to limit differences between reference sample values of the current sample value of the current video region and the current sample value before application said one or more first filtering parameters; And performing a conversion between the current video region and the video bitstream based on a nonlinear adaptive contour filtering operation; wherein a set of constraint parameters is created based on a bit depth and a constraint index based on a given table, wherein in a given table, the value of one constraint parameter corresponding to the first constraint index for a given bit depth is obtained based on the value of another constraint parameter corresponding to the first constraint index for different bit depth. 14. A computer-readable durable storage medium that stores instructions that cause the processor to execute: determining that a nonlinear adaptive contour filtering operation is applied to the current video region of the video, wherein the current video region is a coding tree block; obtaining at least one first filtering index for the current video area and obtaining one or more first filtering parameters based on the at least one first filtering index; obtaining one or more first constraint parameters from the set of constraint parameters based on said at least one first filtering index, performing a limiting operation that is part of a nonlinear adaptive contour filtering operation based on said one or more first limiting parameters, wherein said one or more first limiting parameters are used to limit differences between reference sample values of the current sample value of the current video region and the current sample value before application said one or more first filtering parameters; And performing a conversion between the current video region and the video bitstream based on a nonlinear adaptive contour filtering operation; wherein a set of constraint parameters is created based on a bit depth and a constraint index based on a given table, wherein in a given table, the value of one constraint parameter corresponding to the first constraint index for a given bit depth is obtained based on the value of another constraint parameter corresponding to the first constraint index for different bit depth. 15. A method for storing a video bitstream, comprising the steps of: determining that a nonlinear adaptive contour filtering operation is applied to the current video region of the video, wherein the current video region is a coding tree block; obtaining at least one first filtering index for the current video area and obtaining one or more first filtering parameters based on the at least one first filtering index; obtaining one or more first constraint parameters from the set of constraint parameters based on said at least one first filtering index; perform a limiting operation that is part of a nonlinear adaptive contour filtering operation based on said one or more first limiting parameters, wherein said one or more first limiting parameters are used to limit differences between reference sample values of the current sample value of the current video area and the current sample value before applying said one or more first filtering parameters; generating a video bitstream based on the limiting operation; And storing the bit stream on a computer readable storage medium; wherein a set of constraint parameters is created based on a bit depth and a constraint index based on a given table, wherein in a given table, the value of one constraint parameter corresponding to the first constraint index for a given bit depth is obtained based on the value of another constraint parameter corresponding to the first constraint index for different bit depth.