Controlling deblocking filtering at different levels in coded video

Abstract

Methods and apparatus for video processing are disclosed. The processing can include video encoding, video decoding, or video transcoding. An example method includes performing a conversion between a video comprising a picture comprising one or more slices and a bitstream of the video, wherein the conversion conforms to a rule that specifies whether a deblocking filter is applied to one or more slices of a reference picture parameter set based on at least a first syntax element included in a picture parameter set, and wherein the first syntax element indicates whether the deblocking filter is disabled for the picture.

Description

[0001] Cross-reference of related applications

[0002] This application is made to promptly claim priority and benefits from International Patent Application No. PCT / CN2020 / 080602, filed on March 23, 2020. The entire disclosure of the aforementioned application is incorporated herein by reference as part of the disclosure of this application. Technical Field

[0003] This patent document relates to image and video encoding and decoding. Background Technology

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

[0005] This document discloses techniques that can be used by video encoders and decoders to process the codec representation of video using control information useful for decoding the codec representation.

[0006] In one example aspect, a video processing method is disclosed. The method includes performing a conversion between a video comprising images containing one or more stripes and a video bitstream, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to one or more stripes of a reference image parameter set based at least on a first syntax element included in the image parameter set, and wherein the first syntax element indicates whether the deblocking filter is disabled for the images.

[0007] In another example, a video processing method is disclosed. This method includes performing a conversion between a video comprising images containing one or more stripes and a video bitstream.

[0008] The conversion conforms to a rule that specifies whether a deblocking filter is applied to one or more stripes of a reference image parameter set based solely on a syntax element included in the image parameter set that indicates whether the deblocking filter is disabled.

[0009] In another example, a video processing method is disclosed. The method performs a conversion between a video comprising one or more images and a video bitstream, the one or more images comprising one or more stripes, wherein the bitstream conforms to a rule specifying whether to overwrite a deblocking operation on a stripe or image at the stripe level or the image level based on a first value of a first syntax element at the stripe level or a second value of a second syntax element at the image level, and wherein the rule specifies that, in response to the absence of a first syntax element in the stripe header, the first value of the first syntax element is determined independently of the second value of the second syntax element at the image level.

[0010] In another example, a video processing method is disclosed. This method performs a conversion between a video comprising one or more images and a video bitstream, the one or more images comprising one or more stripes, wherein the bitstream conforms to a rule specifying whether a deblocking parameter is included in a stripe header or an image header based on a first value of a first syntax element at the stripe level or a second value of a second syntax element at the image level, and wherein the rule specifies that, in response to the absence of a first syntax element in the stripe header, the first value of the first syntax element is determined independently of the second value of the second syntax element at the image level.

[0011] In another example, a video processing method is disclosed. The method performs a conversion between a video comprising one or more images and a video bitstream, the one or more images comprising one or more stripes, wherein the bitstream conforms to a format rule specifying whether a first syntax element and a second syntax element are respectively included in the image header and stripe header, or whether the first syntax element and the second syntax element are inferred based on the value of a third syntax element in a set of image parameters, wherein the first syntax element indicates whether a deblocking filter is disabled at the image level of the video, wherein the second syntax element indicates whether a deblocking filter is disabled at the stripe level of the video, and wherein the third syntax element indicates whether a deblocking filter is enabled for one or more images of a reference set of image parameters.

[0012] In another example, a video processing method is disclosed. This method performs a conversion between a video comprising one or more images and a video bitstream, the one or more images comprising one or more slices, wherein the conversion conforms to rules specifying whether a deblocking filter is applied to a slice based on syntax elements included in the slice header and / or image header and / or image parameter set referenced by the slice, and wherein the syntax elements indicate whether the deblocking filter is enabled at the image parameter set level and / or the slice level and / or the image level.

[0013] In another example, a video processing method is disclosed. The method performs a conversion between a video comprising one or more images and a video bitstream, the one or more images comprising one or more stripes, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to the stripe based on syntax elements included in a set of sequence parameters referenced by the stripe, and wherein the syntax elements include a first syntax element indicating whether the deblocking filter is enabled and / or a set of syntax elements indicating a first set of parameters for the deblocking filter.

[0014] In another example, a video processing method is disclosed. A conversion is performed between a video comprising one or more images and a video bitstream, the one or more images comprising one or more slices, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to a slice based on non-binary syntax elements included at the video unit level, and wherein the non-binary syntax elements indicate whether and / or how the deblocking filter is applied to one or more slices.

[0015] In another example, a video processing method is disclosed. A conversion is performed between a video comprising one or more images and a video bitstream, the one or more images comprising one or more stripes, wherein the conversion conforms to rules specifying that: (1) a deblocking filter is enabled at the image level or the stripe level of the video, and (2) zero-valued deblocking parameter offsets of β and tC are used for the parameters of the deblocking filter.

[0016] In another example, a video processing method is disclosed. The method includes: determining the size of a predicted block corresponding to a video block according to a rule for conversion between video blocks and a bitstream of the video; and performing a conversion based on the determination, wherein the rule specifies a first size of the predicted block in response to whether a prediction refinement technique using optical flow is used to encode and decode the video block, and wherein the video block has a second size and is encode and decoded using an affine merge mode or an affine advanced motion vector prediction mode.

[0017] In another example, a video processing method is disclosed. This method includes performing a conversion between a video and a video bitstream comprising one or more images containing one or more stripes, wherein a rule specifies a first syntax element at a video level higher than the image level or stripe level, and wherein the first syntax element indicates whether the image level or stripe level includes a quantization parameter increment.

[0018] In another example, a video processing method is disclosed. The method includes performing a conversion between a video comprising one or more images containing one or more stripes and a bitstream of that video, wherein a first rule specifies a first flag in a first video level indicating whether one or more chroma metric parameter offsets are included in the first video level, wherein the first video level is higher than the stripe level, wherein a second rule specifies a second flag in a second video level indicating whether one or more chroma metric parameter offsets are included in an image header or a stripe header, and wherein the second video level is higher than the image level.

[0019] In another example, a video processing method is disclosed. This method includes performing a conversion between a video comprising one or more images containing one or more stripes and a video bitstream, wherein the bitstream includes a first syntax element indicating codec block segmentation values, and wherein the codec block segmentation values ​​have a range according to rules.

[0020] In another example, a video processing method is disclosed. This method includes performing a conversion between videos comprising one or more video images, the one or more video images comprising one or more video strips, wherein the conversion conforms to a first rule that specifies that a determination of the applicability of a deblocking filter for a set of parameters of one or more video strips is performed based on a deblocking syntax field included in the image header of the respective video image.

[0021] In another example, a different video processing method is disclosed. This method includes performing a transformation between videos comprising one or more video images, which in turn comprise one or more video stripes, wherein the transformation conforms to a rule that specifies constraints on the applicability of a deblocking filter for the video stripes based on fields included at the strip header level and / or picture header level and / or picture parameter set level in the video stripes.

[0022] In another example, a different video processing method is disclosed. This method includes determining the suitability of prediction-refinement-based optical flow (PROF) encoding / decoding with either a first-rule-based affine high-level motion vector prediction encoding / decoding or a second-rule-based affine merge mode; and performing a conversion between video blocks and the encoded / decoded representation of the video based on this determination.

[0023] In another example, a different video processing method is disclosed. This method includes performing a conversion between a video comprising one or more pictures containing one or more stripes and a codec representation of that video, wherein a first syntax element at the picture level or stripe level and / or a second syntax element at another level indicating quantization parameter increments or offset signaling notifications are conditionally included in the codec representation according to rules.

[0024] In another example, a different video processing method is disclosed. This method includes performing a conversion between a video comprising one or more images containing one or more stripes and a codec representation of that video, wherein the codec representation includes syntax elements indicating codec block subdivision values ​​(cbSubDiv), the range of which is based on rules.

[0025] In yet another example, a video codec apparatus is disclosed. The video codec includes a processor configured to implement the methods described above.

[0026] In yet another example, a video decoder apparatus is disclosed. The video decoder includes a processor configured to implement the methods described above.

[0027] In yet another example, a computer-readable medium on which code is stored is disclosed. This code embodies one of the methods described herein in the form of processor-executable code.

[0028] These and other features will be described in this document. Attached Figure Description

[0029] Figure 1 This is a block diagram of an example video processing system.

[0030] Figure 2 This is a block diagram of a video processing device.

[0031] Figure 3 A flowchart of an example method for video processing.

[0032] Figure 4 This is a block diagram illustrating a video encoding / decoding system according to some embodiments of the present disclosure.

[0033] Figure 5 This is a block diagram illustrating an encoder according to some embodiments of the present disclosure.

[0034] Figure 6 This is a block diagram illustrating a decoder according to some embodiments of the present disclosure.

[0035] Figures 7 to 19 This is a flowchart of an example method for video processing. Detailed Implementation

[0036] The use of chapter headings in this document is for ease of understanding and does not limit the applicability of the techniques and embodiments disclosed in each chapter to that chapter only. Furthermore, the use of H.266 terminology in some descriptions is merely for ease of understanding and not to limit the scope of the disclosed techniques. Therefore, the techniques described herein are also applicable to other video codec protocols and designs.

[0037] 1. Introduction

[0038] This document relates to video codec technologies. Specifically, it concerns support for deblocking signaling notification, QP delta / offset signaling notification, cbSubdiv value definition for quantization groups, and PROF processing in video codecs. These ideas can be applied individually or in various combinations to any standard or non-standard video codec that supports multi-layer video codecs (e.g., the Multi-Functional Video Codec (VVC) under development).

[0039] 2. Abbreviation

[0040] APS Adaptive Parameter Set

[0041] AU Access Unit

[0042] AUD Access Unit Separator

[0043] AVC Advanced Video Codec

[0044] CLVS codec layer video sequence

[0045] CPB image buffer

[0046] CRA Clean Random Access

[0047] CTU (Codec Tree Unit)

[0048] CVS codec video sequence

[0049] DPB Decoding Image Buffer

[0050] DPS Decoding Parameter Set

[0051] EOB bitstream end

[0052] EOS sequence ends

[0053] GDR Gradual Decoding and Refresh

[0054] HEVC High-Efficiency Video Encoding and Decoding

[0055] HRD Assumption Reference Decoder

[0056] IDR Instant Decoding and Refresh

[0057] JEM Joint Exploration Model

[0058] MCTS Motion Constraint Pieces

[0059] NAL Network Abstraction Layer

[0060] OLS Output Layer Set

[0061] PH image header

[0062] PPS Image Parameter Set

[0063] PROF uses optical flow prediction refinement

[0064] PTL (Level, Grade, Class)

[0065] PU Image Unit

[0066] RBSP raw byte sequence payload

[0067] SEI Supplemental Enhancement Information

[0068] SH strip header

[0069] SPS Sequence Parameter Set

[0070] SVC Scalable Video Codec

[0071] VCL (Video Codec Layer)

[0072] VPS Video Parameter Set

[0073] VTM VVC Test Model

[0074] VUI Video Availability Information

[0075] VVC Multi-Functional Video Encoding and Decoding

[0076] 3. Preliminary Discussion

[0077] Video codec standards have primarily evolved through the development of well-known ITU-T and ISO / IEC standards. ITU-T developed the H.261 and H.263 standards, while ISO / IEC developed the MPEG-1 and MPEG-4 Visual standards. The two organizations jointly developed the H.262 / MPEG-2 video standard, the H.264 / MPEG-4 Advanced Video Codec (AVC) standard, and the H.265 / HEVC standard. Starting with H.262, video codec standards are based on a hybrid video codec architecture, utilizing temporal prediction plus transform coding. To explore future video codec technologies beyond HEVC, the Joint Video Exploration Team (JVET) was jointly established by VCEG and MPEG in 2015. Since then, JVET has adopted many new methods and incorporated them into reference software called the Joint Exploration Model (JEM). JVET meetings are held quarterly, and the goal of new codec standards is to reduce the bitrate by 50% compared to HEVC. The new video codec standard was officially named Multifunctional Video Coding (VVC) at the JVET meeting in April 2018, and the first version of the VVC Test Model (VTM) was also released at that time. With ongoing efforts to standardize VVC, new codec technologies have been adopted into the VVC standard at each JVET meeting. The VVC working draft and test model VTM are updated after each meeting. The current goal of the VVC project is to achieve Technical Completion (FDIS) at the meeting in July 2020.

[0078] 3.1. PPS Syntax and Semantics

[0079] In the latest VVC draft text, the GCI syntax and semantics are as follows:

[0080]

[0081]

[0082]

[0083]

[0084]

[0085]

[0086] The PPS RBSP should be available for the decoding process before being referenced, including in at least one AU where the TemporalId is less than or equal to the TemporalId of the PPS NAL unit, or provided by external means.

[0087] All PPS NAL cells within a PU that have a specific value for pps_pic_parameter_set_id should have the same content.

[0088] The pps_pic_parameter_set_id identifies the PPS referenced by other syntax elements. The value of pps_pic_parameter_set_id should be in the range of 0 to 63 (inclusive).

[0089] Regardless of the nuh_layer_id value, PPS NAL units share the same value space for pps_pic_parameter_set_id.

[0090] Let ppsLayerId be the value of numh_layer_id for a specific PPS NAL cell, and vclLayerId be the value of numh_layer_id for a specific VCL NAL cell. A specific VCL NAL cell should not refer to a specific PPS NAL cell unless a layer whose ppsLayerId is less than or equal to vclLayerId and whose nuh_layer_id is equal to ppsLayerId is contained in at least one OLS that includes layers whose nuh_layer_id is equal to vclLayerId.

[0091] The `pps_seq_parameter_set_id` parameter specifies the value of `sps_seq_parameter_set_id` for the SPS. The value of `pps_seq_parameter_set_id` should be in the range of 0 to 15 (inclusive). The value of `pps_seq_parameter_set_id` should be the same across all PPSs referenced by the codec image in CLVS.

[0092] A mixed_nalu_types_in_pic_flag value of 1 indicates that each image in the reference PPS has multiple VCLNAL units, the VCLNAL units do not have the same nal_unit_type value, and the image is not an IRAP image. A mixed_nalu_types_in_pic_flag value of 0 indicates that each image in the reference PPS has one or more VCL NAL units, and the VCL NAL units of each image in the reference PPS have the same nal_unit_type value.

[0093] When no_mixed_nalu_types_in_pic_constraint_flag equals 1, the value of mixed_nalu_types_in_pic_flag should be equal to 0.

[0094] For each stripe in image picA that has a nal_unit_type value nalUnitTypeA in the range IDR_W_RADL to CRA_NUT (inclusive), and image picA also contains one or more stripes with another value of nal_unit_type (i.e., the value of mixed_nalu_types_in_pic_flag of image picA is equal to 1), the following applies:

[0095] - The stripe should belong to the subpicA whose corresponding subpic_treated_as_pic_flag[i] value is 1.

[0096] - A stripe should not belong to a subpico of a picA containing a VCL NAL unit whose nal_unit_type is not equal to nalUnitTypeA.

[0097] - If nalUnitTypeA equals CRA, then for all subsequent PUs in CLVS that are after the current picture in the decoding and output order, neither RefPicList[0] nor RefPicList[1] of the stripes in subpicA of these PUs should be included in any picture in the active entry that is before picA in the decoding order.

[0098] - Otherwise (i.e., nalUnitTypeA equals IDR_W_RADL or IDR_N_LP), for all PUs in CLVS that are after the current picture in the decoding order, neither RefPicList[0] nor RefPicList[1] of the stripes in subpicA of these PUs should be included in any picture in the active entry that is before picA in the decoding order.

[0099] Note 1 – `mixed_nalu_types_in_pic_flag` equal to 1 indicates that the reference PPS image contains stripes with different NAL unit types, for example, codec images derived from sub-picture bitstream merge operations. The encoder must ensure that the bitstream structure matches and further aligns the parameters of the original bitstream. An example of this alignment is as follows: when `sps_idr_rpl_flag` is equal to 0 and `mixed_nalu_types_in_pic_flag` is equal to 1, the reference PPS image cannot have stripes with `nal_unit_type` equal to `IDR_W_RADL` or `IDR_N_LP`.

[0100] `pic_width_in_luma_samples` specifies the width of each decoded image referenced by PPS, in luminance samples. `pic_width_in_luma_samples` should not be equal to 0, should be an integer multiple of Max(8, MinCbSizeY), and should be less than or equal to `pic_width_max_in_luma_samples`.

[0101] When res_change_in_clvs_allowed_flag equals 0, the value of pic_width_in_luma_samples should be equal to pic_width_max_in_luma_samples.

[0102] `pic_height_in_luma_samples` specifies the height of each decoded image referenced to the PPS, in units of luminance samples. `pic_height_in_luma_samples` should not be equal to 0 and should be an integer multiple of `Max(8, MinCbSizeY)`, and should be less than or equal to `pic_height_max_in_luma_samples`.

[0103] When res_change_in_clvs_allowed_flag equals 0, the value of pic_height_in_luma_samples should be equal to pic_height_max_in_luma_samples.

[0104] The derivation of the variables PicWidthInCtbsY, PicHeightInCtbsY, PicSizeInCtbsY, PicWidthInMinCbsY, PicHeightInMinCbsY, PicSizeInMinCbsY, PicSizeInSamplesY, PicWidthInSamplesC, and PicHeightInSamplesC is as follows:

[0105] PicWidthInCtbsY = Ceil(pic_width_in_luma_samples ÷ CtbSizeY) (69)

[0106] PicHeightInCtbsY = Ceil(pic_height_in_luma_samples ÷ CtbSizeY) (70)

[0107] PicSizeInCtbsY = PicWidthInCtbsY * PicHeightInCtbsY (71)

[0108] PicWidthInMinCbsY = pic_width_in_luma_samples / MinCbSizeY (72)

[0109] PicHeightInMinCbsY = pic_height_in_luma_samples / MinCbSizeY (73)

[0110] PicSizeInMinCbsY = PicWidthInMinCbsY * PicHeightInMinCbsY (74)

[0111] PicSizeInSamplesY = pic_width_in_luma_samples * pic_height_in_luma_samples (75)

[0112] PicWidthInSamplesC = pic_width_in_luma_samples / SubWidthC (76)

[0113] PicHeightInSamplesC = pic_height_in_luma_samples / SubHeightC (77)

[0114] A pps_conformance_window_flag value of 1 indicates that the consistency trimming window offset parameter immediately follows in PPS. A pps_conformance_window_flag value of 0 indicates that the consistency trimming window offset parameter does not exist in PPS.

[0115] `pps_conf_win_left_offset`, `pps_conf_win_right_offset`, `pps_conf_win_top_offset`, and `pps_conf_win_bottom_offset` specify the sample points of the image in the CLVS output from the decoding process, outputting them according to the rectangular region specified in the image coordinates. When `pps_conformance_window_flag` equals 0, the values ​​of `pps_conf_win_left_offset`, `pps_conf_win_right_offset`, `pps_conf_win_top_offset`, and `pps_conf_win_bottom_offset` are inferred to be equal to 0.

[0116] The consistent cropping window contains luminance samples, where the horizontal image coordinates range from SubWidthC*pps_conf_win_left_offset to pic_width_in_luma_samples-(SubWidthC*pps_conf_win_right_offset+1), and the vertical image coordinates range from SubHeightC*pps_conf_win_top_offset to pic_height_in_luma_samples-(SubHeightC*pps_conf_win_bottom_offset+1), including end values.

[0117] The value of SubWidthC*(pps_conf_win_left_offset+pps_conf_win_right_offset) should be less than pic_width_in_luma_samples, and the value of SubHeightC*(pps_conf_win_top_offset+pps_conf_win_bottom_offset) should be less than pic_height_in_luma_samples.

[0118] When ChromaArrayType is not equal to 0, the corresponding specified sample points of the two chroma arrays are sample points with image coordinates (x / SubWidthC, y / SubHeightC), where (x, y) are the image coordinates of the specified brightness sample point.

[0119] Note 2 – The consistent cropping window offset parameter applies only to the output. All internal decoding processes are applied to the uncropped image size.

[0120] Assume ppsA and ppsB are any two PPSs referencing the same SPS. The requirement for bitstream consistency is that when ppsA and ppsB have the same pic_width_in_luma_samples and pic_height_in_luma_samples values, respectively, ppsA and ppsB should also have the same pps_conf_win_left_offset, pps_conf_win_right_offset, pps_conf_win_top_offset, and pps_conf_win_bottom_offset values, respectively.

[0121] When pic_width_in_luma_samples equals pic_width_max_in_luma_samples and pic_height_in_luma_samples equals pic_height_max_in_luma_samples, the bitstream consistency requirement is that pps_conf_win_left_offset, pps_conf_win_right_offset, pps_conf_win_top_offset, and pps_conf_win_bottom_offset are equal to sps_conf_win_left_offset, sps_conf_win_right_offset, sps_conf_win_top_offset, and sps_conf_win_bottom_offset, respectively.

[0122] A scaling_window_explicit_signaling_flag value of 1 indicates that the scaling window offset parameter exists in the PPS. A scaling_window_explicit_signaling_flag value of 0 indicates that the scaling window offset parameter does not exist in the PPS. When res_change_in_clvs_allowed_flag is equal to 0, the value of scaling_window_explicit_signaling_flag should be equal to 0.

[0123] `scaling_win_left_offset`, `scaling_win_right_offset`, `scaling_win_top_offset`, and `scaling_win_bottom_offset` specify the offsets of the image size applied to the scaling calculation. When these values ​​are not present, they are inferred to be equal to `pps_conf_win_left_offset`, `pps_conf_win_right_offset`, `pps_conf_win_top_offset`, and `pps_conf_win_bottom_offset`, respectively.

[0124] The value of SubWidthC*(scaling_win_left_offset+scaling_win_right_offset) should be less than pic_width_in_luma_samples, and the value of SubHeightC*(scaling_win_top_offset+scaling_win_bottom_offset) should be less than pic_height_in_luma_samples.

[0125] The variables PicOutputWidthL and PicOutputHeightL are derived as follows:

[0126] PicOutputWidthL=pic_width_in_luma_samples- (78)

[0127] SubWidthC*(scaling_win_right_offset+scaling_win_left_offset)

[0128] PicOutputHeightL=pic_height_in_luma_samples- (79)

[0129] SubWidthC*(scaling_win_bottom_offset+scaling_win_top_offset)

[0130] Assume that refPicOutputWidthL and refPicOutputHeightL are the PicOutputWidthL and PicOutputHeightL of the reference image that references the current image of this PPS, respectively. Bitstream consistency requires that all of the following conditions be met:

[0131] –PicOutputWidthL*2 should be greater than or equal to refPicWidthInLumaSamples.

[0132] –PicOutputHeightL*2 should be greater than or equal to refPicHeightInLumaSamples.

[0133] –PicOutputWidthL should be less than or equal to refPicWidthInLumaSamples*8.

[0134] –PicOutputHeightL should be less than or equal to refPicHeightInLumaSamples*8.

[0135] –PicOutputWidthL*pic_width_max_in_luma_samples should be greater than or equal to refPicOutputWidthL*(pic_width_in_luma_samples-Max(8,MinCbSizeY)).

[0136] –PicOutputHeightL*pic_height_max_in_luma_samples should be greater than or equal to refPicOutputHeightL*(pic_height_in_luma_samples-Max(8,MinCbSizeY)).

[0137] A value of 1 for `output_flag_present_flag` indicates that the `pic_output_flag` syntax element exists in the header of the reference PPS. A value of 0 for `output_flag_present_flag` indicates that the `pic_output_flag` syntax element does not exist in the header of the reference PPS.

[0138] `subpic_id_mapping_in_pps_flag` equal to 1 specifies that signaling notification of subpicture ID mapping is performed in the PPS. `subpic_id_mapping_in_pps_flag` equal to 0 specifies that signaling notification of subpicture ID mapping is not performed in the PPS. If `subpic_id_mapping_explicitly_signalled_flag` is 0 or `subpic_id_mapping_in_sps_flag` is 1, then the value of `subpic_id_mapping_in_pps_flag` should be 0. Otherwise (where `subpic_id_mapping_explicitly_signalled_flag` is 1 and `subpic_id_mapping_in_sps_flag` is 0), the value of `subpic_id_mapping_in_pps_flag` should be 1.

[0139] pps_num_subpics_minus1 should be equal to sps_num_subpics_minus1.

[0140] pps_subpic_id_len_minus1 should be equal to sps_subpic_id_len_minus1.

[0141] pps_subpic_id[i] specifies the subpick ID of the i-th subpick. The length of the pps_subpic_id[i] syntax element is pps_subpic_id_len_minus1+1 bits.

[0142] For each value of i in the range from 0 to sps_num_subpics_minus1 (inclusive), the variable SubpicIdVal[i] is derived as follows:

[0143]

[0144] Bitstream consistency requires the application of the following two constraints:

[0145] --For any two distinct values ​​of i and j in the range from 0 to sps_num_subpics_minus1 (inclusive), SubpicIdVal[i] should not be equal to SubpicIdVal[j].

[0146] --When the current image is not the first image of CLVS, for each i value in the range of 0 to sps_num_subpics_minus1 (inclusive of end values), if the value of SubpicIdVal[i] is not equal to the value of SubpicIdVal[i] of the previous image in the same layer in the decoding order, then the nal_unit_type of all codec strip NAL units of the subpics in the current image with subpic index i should be equal to a specific value in the range of IDR_W_RADL to CRA_NUT (inclusive of end values).

[0147] `no_pic_partition_flag` equal to 1 indicates that no image segmentation is applied to each image in the reference PPS. `no_pic_partition_flag` equal to 0 indicates that each image in the reference PPS can be segmented into multiple slices or strips.

[0148] The requirement for bitstream consistency is that the value of no_pic_partition_flag should be the same for all PPS referenced by the encoding and decoding images within CLVS.

[0149] The requirement for bitstream consistency is that when the value of sps_num_subpics_minus1+1 is greater than 1, the value of no_pic_partition_flag should not be equal to 1.

[0150] The value pps_log2_ctu_size_minus5 plus 5 specifies the luma codec tree block size for each CTU. pps_log2_ctu_size_minus5 should be equal to sps_log2_ctu_size_minus5.

[0151] The increment of 1 in `num_exp_tile_columns_minus1` specifies the number of explicitly provided tile column widths. The value of `num_exp_tile_columns_minus1` should be in the range of 0 to `PicWidthInCtbsY–1` (inclusive). When `no_pic_partition_flag` equals 1, the value of `num_exp_tile_columns_minus1` is inferred to be 0.

[0152] The increment of 1 in `num_exp_tile_rows_minus1` specifies the number of explicitly provided tile row heights. The value of `num_exp_tile_rows_minus1` should be in the range of 0 to `PicHeightInCtbsY–1` (inclusive). When `no_pic_partition_flag` is equal to 1, the value of `num_tile_rows_minus1` is inferred to be equal to 0.

[0153] `tile_column_width_minus1[i]` incremented by 1 specifies the width of the i-th tile column in CTB units, ranging from 0 to `num_exp_tile_columns_minus1-1` (inclusive). `tile_column_width_minus1[num_exp_tile_columns_minus1]` is used to derive the width of tile columns whose index is greater than or equal to `num_exp_tile_columns_minus1` as specified in Clause 6.5.1. The value of `tile_column_width_minus1[i]` should be in the range of 0 to `PicWidthInCtbsY–1` (inclusive). When it does not exist, the value of `tile_column_width_minus1[0]` is inferred to be equal to `PicWidthInCtbsY-1`.

[0154] `tile_row_height_minus1[i]` incremented by 1 specifies the height of the i-th slice row in CTB units, ranging from 0 to `num_exp_tile_rows_minus1-1` (inclusive). `tile_row_height_minus1[num_exp_tile_rows_minus1]` is used to derive the height of slice rows whose index is greater than or equal to `num_exp_tile_rows_minus1` as specified in Clause 6.5.1. The value of `tile_row_height_minus1[i]` should be in the range from 0 to `PicHeightInCtbsY-1` (inclusive). When it does not exist, the value of `tile_row_height_minus1[0]` is inferred to be equal to `PicHeightInCtbsY-1`.

[0155] A `rect_slice_flag` value of 0 indicates that slices within each slice are in the raster scan order, and slice information is not signaled in the PPS. A `rect_slice_flag` value of 1 indicates that slices within each slice cover a rectangular area of ​​the image, and slice information is signaled in the PPS. When it does not exist, `rect_slice_flag` is inferred to be equal to 1. When `subpic_info_present_flag` is equal to 1, the value of `rect_slice_flag` should be equal to 1.

[0156] A single_slice_per_subpic_flag value of 1 indicates that each subpicture consists of one and only one rectangular stripe. A single_slice_per_subpic_flag value of 0 indicates that each subpicture can consist of one or more rectangular stripes. When single_slice_per_subpic_flag is 1, num_slices_in_pic_minus1 is inferred to be equal to sps_num_subpics_minus1. When it does not exist, the value of single_slice_per_subpic_flag is inferred to be 0.

[0157] `num_slices_in_pic_minus1` incremented by 1 specifies the number of rectangular stripes in each picture of the reference PPS. The value of `num_slices_in_pic_minus1` should be in the range of 0 to `MaxSlicesPerPicture – 1` (inclusive), where `MaxSlicesPerPicture` is specified in Appendix A. When `no_pic_partition_flag` equals 1, the value of `num_slices_in_pic_minus1` is inferred to be equal to 0.

[0158] A tile_idx_delta_present_flag value of 0 indicates that the tile_idx_delta value does not exist in the PPS, and all rectangular stripes in the PPS image are specified in raster order according to the procedure defined in Clause 6.5.1. A tile_idx_delta_present_flag value of 1 indicates that the tile_idx_delta value may exist in the PPS, and all rectangular stripes in the PPS image are specified in the order indicated by the tile_idx_delta value. When it does not exist, the value of tile_idx_delta_present_flag is inferred to be equal to 0.

[0159] `slice_width_in_tiles_minus1[i]` incremented by 1 specifies the width of the i-th rectangular strip in units of slice columns. The value of `slice_width_in_tiles_minus1[i]` should be in the range of 0 to `NumTileColumns–1` (inclusive).

[0160] The following applies when slice_width_in_tiles_minus1[i] does not exist:

[0161] --If NumTileColumns equals 1, then the value of slice_width_in_tiles_minus1[i] is inferred to be equal to 0.

[0162] --Otherwise, infer the value of slice_width_in_tiles_minus1[i] according to Clause 6.5.1.

[0163] `slice_height_in_tiles_minus1[i]` incremented by 1 specifies the height of the i-th rectangular strip in units of slices. The value of `slice_height_in_tiles_minus1[i]` should be in the range of 0 to NumTileRows–1 (inclusive).

[0164] The following applies when slice_height_in_tiles_minus1[i] does not exist:

[0165] --If NumTileRows equals 1, or tile_idx_delta_present_flag equals 0, and tileIdx%NumTileColumns is greater than 0, then the value of slice_height_in_tiles_minus1[i] is inferred to be equal to 0.

[0166] --Otherwise (NumTileRows is not equal to 1, and tile_idx_delta_present_flag is equal to 1 or tileIdx%NumTileColumns is equal to 0), when tile_idx_delta_present_flag is equal to 1 or tileIdx%NumTileColumns is equal to 0, the value of slice_height_in_tiles_minus1[i] is inferred to be equal to slice_height_in_tiles_minus1[i-1].

[0167] `num_exp_slices_in_tile[i]` specifies the number of slice heights explicitly provided in the current slice containing multiple rectangular slices. The value of `num_exp_slices_in_tile[i]` should be in the range of 0 to `RowHeight[tileY] – 1` (inclusive), where `tileY` is the slice row index containing the `i`-th slice. When it does not exist, the value of `num_exp_slices_in_tile[i]` is inferred to be equal to 0. When `num_exp_slices_in_tile[i]` is equal to 0, the value of the variable `NumSlicesInTile[i]` is derived to be equal to 1.

[0168] The value of exp_slice_height_in_ctus_minus1[j], incremented by 1, specifies the height of the j-th rectangular stripe in the current slice, in units of CTU rows. The value of exp_slice_height_in_ctus_minus1[j] should be in the range of 0 to RowHeight[tileY] – 1 (inclusive), where tileY is the slice row index of the current slice.

[0169] When num_exp_slices_in_tile[i] is greater than 0, the SliceHeightInCtusMinus1[i+k] of variables NumSlicesInTile[i] and k in the range of 0 to NumSlicesInTile[i]-1 (inclusive) is derived as follows:

[0170]

[0171] `tile_idx_delta[i]` specifies the difference between the tile index of the first piece in the i-th rectangular strip and the tile index of the first piece in the (i+1)-th rectangular strip. The value of `tile_idx_delta[i]` should be in the range of -NumTilesInPic+1 to NumTilesInPic–1 (inclusive). When it does not exist, the value of `tile_idx_delta[i]` is inferred to be equal to 0. When it exists, the value of `tile_idx_delta[i]` should not be equal to 0.

[0172] A `loop_filter_across_tiles_enabled_flag` value of 1 indicates that loop filtering operations can be performed across tile boundaries in the reference PPS image. A `loop_filter_cross_tiles_enabled_flag` value of 0 indicates that loop filtering operations are not performed across tile boundaries in the reference PPS image. Loop filtering operations include deblocking filtering, sample adaptive offset filtering, and adaptive loop filtering operations. When it does not exist, the value of `loop_filter_cross_tiles_enabled_flag` is inferred to be equal to 1.

[0173] A `loop_filter_cross_slices_enabled_flag` value of 1 indicates that loop filtering operations can be performed across slice boundaries in the reference PPS image. A `loop_filter_cross_slice_enabled_flag` value of 0 indicates that loop filtering operations are not performed across slice boundaries in the reference PPS image. Loop filtering operations include deblocking filters, sample adaptive offset filters, and adaptive loop filter operations. When it does not exist, the value of `loop_filter_cross_slices_enabled_flag` is inferred to be 0.

[0174] A cabac_init_present_flag value of 1 indicates that the cabac_init_flag exists in the reference PPS stripe header. A cabac_init_present_flag value of 0 indicates that the cabac_init_flag does not exist in the reference PPS stripe header.

[0175] Increment 1 by num_ref_idx_default_active_minus1[i]. When i equals 0, it specifies the inferred value of variable NumRefIdxActive[0] for P-strips or B-strips where num_ref_idx_active_override_flag equals 0. When i equals 1, it specifies the inferred value of NumRefIdxActive[1] for B-strips where num_ref_idx_active_override_flag equals 0. The value of num_ref_idx_default_active_minus1[i] should be in the range of 0 to 14 (inclusive).

[0176] A value of 0 for rpl1_idx_present_flag indicates that ref_pic_list_sps_flag[1] and ref_pic_list_idx[1] do not exist in the PH syntax structure or the strip header of the image referenced in PPS. A value of 1 for rpl1_idx_present_flag indicates that ref_pic_list_sps_flag[1] and ref_pic_list_idx[1] may exist in the PH syntax structure or the strip header of the image referenced in PPS.

[0177] init_qp_minus26 plus 26 specifies the SliceQp for each stripe of PPS. Y The initial value. When a non-zero value of ph_qp_delta is decoded, SliceQp Y The initial value of SliceQp is modified at the image level, or when a non-zero value of slice_qp_delta is decoded. Y The initial value is modified at the stripe level. The value of init_qp_minus26 should be in the range of -(26+QpBdOffset) to +37 (inclusive).

[0178] A flag of 1 for `cu_qp_delta_enabled_flag` indicates that the syntax elements `ph_cu_qp_delta_subdiv_intra_slice` and `ph_cu_qp_delta_subdiv_inter_slice` exist in the PH of the reference PPS, and `cu_qp_delta_abs` may exist in the transformation unit syntax. A flag of 0 for `cu_qp_delta_enabled_flag` indicates that the syntax elements `ph_cu_qp_delta_subdiv_intra_slice` and `ph_cu_qp_delta_subdiv_inter_slice` do not exist in the PH of the reference PPS, and `cu_qp_delta_abs` does not exist in the transformation unit syntax.

[0179] A value of 1 for `pps_chroma_tool_offsets_present_flag` indicates the presence of syntax elements related to chroma tool offsets in the PPS RBSP syntax structure. A value of 0 for `pps_chroma_tool_offsets_present_flag` indicates the absence of such syntax elements in the PPS RBSP syntax structure. When `ChromaArrayType` equals 0, the value of `pps_chroma_tool_offsets_present_flag` should be 0.

[0180] pps_cb_qp_offset and pps_cr_qp_offset are respectively specified for exporting Qp′ Cb and Qp′ Cr Brightness quantization parameter Qp′ Y The values ​​of pps_cb_qp_offset and pps_cr_qp_offset should be in the range of -12 to +12 (inclusive). When ChromaArrayType equals 0, pps_cb_qp_offset and pps_cr_qp_offset are not used during decoding, and the decoder should ignore their values. When they do not exist, the values ​​of pps_cb_qp_offset and pps_cr_qp_offset are inferred to be equal to 0.

[0181] A value of 1 for `pps_joint_cbcr_qp_offset_present_flag` indicates that `pps_joint_cbcr_qp_offset_value` and `joint_cbcr_qp_offset_list[i]` exist in the PPS RBSP syntax structure. A value of 0 for `pps_joint_cbcr_qp_offset_present_flag` indicates that `pps_joint_cbcr_qp_offset_value` and `joint_cbcr_qp_offset_list[i]` do not exist in the PPS RBSP syntax structure. When `ChromaArrayType` equals 0 or `sps_joint_cbcr_enabled_flag` equals 0, the value of `pps_joint_cbcr_qp_offset_present_flag` should be 0. When it does not exist, the value of `pps_joint_cbcr_qp_offset_present_flag` is inferred to be 0.

[0182] pps_joint_cbcr_qp_offset_value specifies the value used to export Qp′. CbCr Brightness quantization parameter Qp′ YThe offset. The value of pps_joint_cbcr_qp_offset_value should be in the range of -12 to +12 (inclusive). When ChromaArrayType equals 0 or sps_joint_cbcr_enabled_flag equals 0, pps_joint_cbcr_qp_offset_value is not used during decoding, and the decoder should ignore its value. When pps_joint_cbcr_qp_offset_present_flag equals 0, pps_joint_cbcr_qp_offset_value does not exist and is inferred to be equal to 0.

[0183] A value of 1 for `pps_slice_chroma_qp_offsets_present_flag` indicates that the `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements exist in the associated slice header. A value of 0 for `pps_slice_chroma_qp_offsets_present_flag` indicates that the `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements do not exist in the associated slice header. When they do not exist, the value of `pps_slice_chroma_qp_offsets_present_flag` is inferred to be 0.

[0184] A value of 1 for `pps_cu_chroma_qp_offset_list_enabled_flag` indicates that the syntax elements `ph_cu_chroma_qp_offset_subdiv_intra_slice` and `ph_cu_chroma_qp_offset_subdiv_inter_slice` exist in the reference PPS's PH, and `cu_chroma_qp_offset_flag` may exist in the Transform Unit syntax and Palette Encoding / Decoding syntax. A value of 0 for `pps_cu_chroma_qp_offset_list_enabled_flag` indicates that the syntax elements `ph_cu_chroma_qp_offset_subdiv_intra_slice` and `ph_cu_chroma_qp_offset_subdiv_inter_slice` do not exist in the reference PPS's PH, and `cu_chroma_qp_offset_flag` does not exist in the Transform Unit syntax and Palette Encoding / Decoding syntax. When it does not exist, the value of `pps_cu_chroma_qp_offset_list_enabled_flag` is inferred to be 0.

[0185] The increment of 1 in `chroma_qp_offset_list_len_minus1` specifies the number of syntax elements `cb_qp_offset_list[i]`, `cr_qp_offset_list[i]`, and `joint_cbcr_qp_offset_list[i]` present in the PPS RBSP syntax structure. The value of `chroma_qp_offset_list_len_minus1` should be in the range of 0 to 5 (inclusive).

[0186] cb_qp_offset_list[i], cr_qp_offset_list[i], and joint_cbcr_qp_offset_list[i] respectively define Qp′ Cb Qp′ Cr and Qp′ CbCr The offsets used in the export. The values ​​of cb_qp_offset_list[i], cr_qp_offset_list[i], and joint_cbcr_qp_offset_list[i] should be in the range of -12 to +12 (inclusive). When pps_joint_cbcr_qp_offset_present_flag equals 0, joint_cbcr_qp_offset_list[i] does not exist and is inferred to be equal to 0.

[0187] A value of 0 for pps_weighted_pred_flag indicates that weighted predictions should not be applied to the P-strips of the reference PPS. A value of 1 for pps_weighted_pred_flag indicates that weighted predictions should be applied to the P-strips of the reference PPS. When sps_weighted_pred_flag is equal to 0, the value of pps_weighted_pred_flag should also be 0.

[0188] A value of 0 for pps_weighted_bipred_flag indicates that explicit weighted predictions should not be applied to the B-strips of the reference PPS. A value of 1 for pps_weighted_bipred_flag indicates that explicit weighted predictions should be applied to the B-strips of the reference PPS. When sps_weighted_bipred_flag is equal to 0, the value of pps_weighted_bipred_flag should also be 0.

[0189] A deblocking filter control present flag of 1 indicates that the PPS contains a deblocking filter control syntax element. A deblocking filter control present flag of 0 indicates that the PPS does not contain a deblocking filter control syntax element.

[0190] A value of 1 for `deblocking_filter_override_enabled_flag` indicates that either `ph_deblocking_filter_override_flag` exists in the PH of the reference PPS, or `slice_deblocking_filter_override_flag` exists in the slice header of the reference PPS. A value of 0 for `deblocking_filter_override_enabled_flag` indicates that either `ph_deblocking_filter_override_flag` does not exist in the PH of the reference PPS, or `slice_deblocking_filter_override_flag` does not exist in the slice header of the reference PPS. When neither exists, the value of `deblocking_filter_override_enabled_flag` is inferred to be 0.

[0191] A value of 1 for `pps_deblocking_filter_disabled_flag` indicates that the deblocking filter operation does not apply to slices referencing PPSs that do not have `slice_deblocking_filter_disabled_flag`. A value of 0 for `pps_deblocking_filter_disabled_flag` indicates that the deblocking filter operation applies to slices referencing PPSs that do not have `slice_deblocking_filter_disabled_flag`. When it does not exist, the value of `pps_deblocking_filter_disabled_flag` is inferred to be 0.

[0192] `pps_beta_offset_div2` and `pps_tc_offset_div2` specify default deblocking parameter offsets for β and tC (divided by 2). These parameter offsets are applied to the luminance component of the reference PPS strip, unless the default deblocking parameter offsets are overridden by deblocking parameter offsets present in the image header or strip header of the reference PPS strip. The values ​​of `pps_beta_offset_div2` and `pps_tc_offset_div2` should both be in the range of -12 to 12 (inclusive). When not present, the values ​​of `pps_beta_offset_div2` and `pps_tc_offset_div2` are inferred to be equal to 0.

[0193] `pps_cb_beta_offset_div2` and `pps_cb_tc_offset_div2` specify default deblocking parameter offsets for β and tC (divided by 2). These parameter offsets are applied to the Cb component of the reference PPS strip, unless the default deblocking parameter offsets are overridden by deblocking parameter offsets present in the image header or strip header of the reference PPS strip. The values ​​of `pps_cb_beta_offset_div2` and `pps_cb_tc_offset_div2` should both be in the range of -12 to 12 (inclusive). When not present, the values ​​of `pps_cb_beta_offset_div2` and `pps_cb_tc_offset_div2` are inferred to be equal to 0.

[0194] `pps_cr_beta_offset_div2` and `pps_cr_tc_offset_div2` specify default deblocking parameter offsets for β and tC (divided by 2). These parameter offsets apply to the Cr component of the reference PPS strip, unless the default deblocking parameter offsets are overridden by deblocking parameter offsets present in the image header or strip header of the reference PPS strip. The values ​​of `pps_cr_beta_offset_div2` and `pps_cr_tc_offset_div2` should both be in the range of -12 to 12 (inclusive). When not present, the values ​​of `pps_cr_beta_offset_div2` and `pps_cr_tc_offset_div2` are inferred to be equal to 0.

[0195] A value of 1 for `rpl_info_in_ph_flag` indicates that the reference image list information exists within the PH syntax structure, but not within the header of a PPS that does not contain a PH syntax structure. A value of 0 for `rpl_info_in_ph_flag` indicates that the reference image list information does not exist within the PH syntax structure, but may exist within the header of a PPS that does not contain a PH syntax structure.

[0196] A value of 1 for `dbf_info_in_ph_flag` indicates that the deblocking filter information exists within the PH syntax structure, but not in the strip header of a PPS that does not contain a PH syntax structure. A value of 0 for `dbf_info_in_ph_flag` indicates that the deblocking filter information does not exist within the PH syntax structure, but may exist in the strip header of a PPS that does not contain a PH syntax structure. When it does not exist, the value of `dbf_info_in_ph_flag` is inferred to be 0.

[0197] A `sao_info_in_ph_flag` value of 1 indicates that the SAO filter information exists within the PH syntax structure, but not within the strip header of a PPS that does not contain a PH syntax structure. A `sao_info_in_ph_flag` value of 0 indicates that the SAO filter information does not exist within the PH syntax structure, but may exist within the strip header of a PPS that does not contain a PH syntax structure.

[0198] An alf_info_in_ph_flag value of 1 indicates that the ALF information exists within the PH syntax structure, but not within the strip header of a PPS that does not contain a PH syntax structure. An alf_info_in_ph_flag value of 0 indicates that the ALF information does not exist within the PH syntax structure, but may exist within the strip header of a PPS that does not contain a PH syntax structure.

[0199] A value of 1 for `wp_info_in_ph_flag` indicates that the weighted prediction information can exist within the PH syntax structure, but not in the strip header of a PPS that does not contain a PH syntax structure. A value of 0 for `wp_info_in_ph_flag` indicates that the weighted prediction information does not exist within the PH syntax structure, but may exist in the strip header of a PPS that does not contain a PH syntax structure. When it does not exist, the value of `wp_info_in_ph_flag` is inferred to be 0.

[0200] A value of 1 for `qp_delta_info_in_ph_flag` indicates that the QP incremental information exists within the PH syntax structure, but not within the stripe header of a PPS that does not contain a PH syntax structure. A value of 0 for `qp_delta_info_in_ph_flag` indicates that the QP incremental information does not exist within the PH syntax structure, but may exist within the stripe header of a PPS that does not contain a PH syntax structure.

[0201] `pps_ref_wraparound_enabled_flag` equal to 1 specifies that horizontal wraparound motion compensation is applied in inter-frame prediction. `pps_ref_wraparound_enabled_flag` equal to 0 specifies that horizontal wraparound motion compensation is not applied. When the value of `CtbSizeY / MinCbSizeY+1` is greater than `pic_width_in_luma_samples / MinCbSizeY-1`, the value of `pps_ref_wraparound_enabled_flag` should be equal to 0. When `sps_ref_wraparound_enabled_flag` is equal to 0, the value of `pps_ref_wraparound_enabled_flag` should also be equal to 0.

[0202] The value of pps_ref_wraparound_offset plus (CtbSizeY / MinCbSizeY) + 2 specifies the offset used to calculate the horizontal wraparound position in units of MinCbSizeY luminance samples. The value of pps_ref_wraparound_offset should be within the range of 0 to (pic_width_in_luma_samples / MinCbSizeY) - (CtbSizeY / MinCbSizeY) - 2 (inclusive).

[0203] The variable PpsRefWraparoundOffset is set to equal pps_ref_wraparound_offset+(CtbSizeY / MinCbSizeY)+2.

[0204] A picture_header_extension_present_flag value of 0 indicates that the PH extension syntax element does not exist in the PH of the reference PPS. A picture_header_extension_present_flag value of 1 indicates that the PH extension syntax element exists in the PH of the reference PPS. In bitstreams conforming to this version of the specification, picture_header_extension_present_flag should be equal to 0.

[0205] A slice_header_extension_present_flag value of 0 indicates that the slice header extension syntax element does not exist in the slice header of the reference PPS codec image. A slice_header_extension_present_flag value of 1 indicates that the slice header extension syntax element exists in the slice header of the reference PPS codec image. In bitstreams conforming to this version of the specification, slice_header_extension_present_flag should be equal to 0.

[0206] A value of 0 for pps_extension_flag indicates that the pps_extension_data_flag syntax element does not exist in the PPS RBSP syntax structure. A value of 1 for pps_extension_flag indicates that the pps_extension_data_flag syntax element exists in the PPS RBSP syntax structure.

[0207] The `pps_extension_data_flag` flag can have any value. Its presence and value do not affect the consistency of the decoder with the grade specified in this version of the specification. Decoders conforming to this version of the specification should ignore all `pps_extension_data_flag` syntax elements.

[0208] 3.2. PH Syntax and Semantics

[0209] In the latest VVC draft text, the PH syntax and semantics are as follows:

[0210]

[0211] The PH RBSP contains the PH syntax structure, namely picture_header_structure().

[0212]

[0213]

[0214]

[0215]

[0216]

[0217]

[0218]

[0219] The PH syntax structure contains common information for all stripes of the encoded / decoded image associated with the PH syntax structure.

[0220] A value of 1 for `gdr_or_irap_pic_flag` indicates that the current image is either a GDR image or an IRAP image. A value of 0 for `gdr_or_irap_pic_flag` indicates that the current image may or may not be a GDR image or an IRAP image.

[0221] A `gdr_pic_flag` value of 1 indicates that the image associated with a `PH` is a GDR image. A `gdr_pic_flag` value of 0 indicates that the image associated with a `PH` is not a GDR image. When it does not exist, the value of `gdr_pic_flag` is inferred to be 0. When `gdr_enabled_flag` is 0, the value of `gdr_pic_flag` should be 0.

[0222] A ph_inter_slice_allowed_flag value of 0 indicates that the slice_type of all codec slices in the image is equal to 2. A ph_inter_slice_allowed_flag value of 1 indicates that the image may or may not contain one or more codec slices with slice_type equal to 0 or 1.

[0223] A value of 0 for `ph_intra_slice_allowed_flag` indicates that the slice_type of all codec slices in the image is either 0 or 1. A value of 1 for `ph_intra_slice_allowed_flag` indicates that the image may or may not contain one or more codec slices with a slice_type of 2. When none exist, the value of `ph_intra_slice_allowed_flag` is inferred to be 1.

[0224] Note 1 – For bitstreams that should be merged based on subpictures without requiring changes to the PH NAL units, the codec should set the values ​​of ph_inter_slice_allowed_flag and ph_intra_slice_allowed_flag to 1.

[0225] A non_reference_picture_flag value of 1 indicates that a picture associated with a pH should never be used as a reference picture. A non_reference_picture_flag value of 0 indicates whether a picture associated with a pH can or cannot be used as a reference picture.

[0226] The `ph_pic_parameter_set_id` parameter specifies the value of `pps_pic_parameter_set_id` for the PPS being used. The value of `ph_pic_parameter_set_id` should be in the range of 0 to 63 (inclusive).

[0227] The requirement for bitstream consistency is that the TemporalId value of PH should be greater than or equal to the TemporalId value of PPS whose pps_pic_parameter_set_id is equal to ph_pic_parameter_set_id.

[0228] `ph_pic_order_cnt_lsb` specifies the image order count of the current image modulo `MaxPicOrderCntLsb`. The length of the `ph_pic_order_cnt_lsb` syntax element is `log2_max_pic_order_cnt_lsb_minus4+4` bits. The value of `ph_pic_order_cnt_lsb` should be in the range of 0 to `MaxPicOrderCntLsb–1` (inclusive).

[0229] The `no_output_of_prior_pics_flag` flag affects the output of previously decoded pictures in the DPB after decoding a CLVSS picture, which is not the first picture in the bitstream specified in Appendix C.

[0230] `recovery_poc_cnt` specifies the recovery point of the decoded images according to the output order. If the current image is a GDR image associated with the PH, and there exists an image `picA` in the CLVS that follows the current GDR image in the decoding order, and its `PicOrderCntVal` is equal to the `PicOrderCntVal` of the current GDR image plus the value of `recovery_poc_cnt`, then image `picA` is called the recovery point image. Otherwise, the first image in the output order whose `PicOrderCntVal` is greater than the `PicOrderCntVal` of the current image plus the value of `recovery_poc_cnt` is called the recovery point image. In the decoding order, the recovery point image should not precede the current GDR image. The value of `recovery_poc_cnt` should be in the range of 0 to `MaxPicOrderCntLsb–1` (inclusive).

[0231] When the current image is a GDR image, the variable RpPicOrderCntVal is exported as follows:

[0232] RpPicOrderCntVal=PicOrderCntVal+recovery_poc_cnt (82)

[0233] Note 2 – When gdr_enabled_flag equals 1 and the current image’s PicOrderCntVal is greater than or equal to the related GDR image’s RpPicOrderCntVal, the current and subsequent decoded images in the output order are completely matched with the corresponding images generated by starting the decoding process from the previous IRAP image (if it exists) before the related GDR image in the decoding order.

[0234] ph_extra_bit[i] can be equal to 1 or 0. Decoders conforming to this version of the specification should ignore the value of ph_extra_bit[i]. Its value does not affect the consistency of the decoder with the grade specified in this version of the specification.

[0235] A value of 1 for `ph_poc_msb_present_flag` indicates that the syntax element `poc_msb_val` exists in the PH. A value of 0 for `ph_poc_msb_present_flag` indicates that the syntax element `poc_msb_val` does not exist in the PH. The value of `ph_poc_msb_present_flag` should be 0 when `vps_independent_layer_flag[GeneralLayerIdx[nuh_layer_id]]` equals 0 and an image exists in the current AU of the current layer's reference layer.

[0236] poc_msb_val specifies the POC MSB value of the current image. The length of the syntax element poc_msb_val is poc_msb_len_minus1+1 bits.

[0237] A `ph_alf_enabled_flag` value of 1 enables the adaptive loop filter for all stripes associated with `PH`, and can be applied to the Y, Cb, or Cr color components within the stripe. A `ph_alf_enabled_flag` value of 0 disables the adaptive loop filter for one or more or all stripes associated with `PH`. When it does not exist, `ph_alf_enabled_flag` is inferred to be equal to 0.

[0238] ph_num_alf_aps_ids_luma specifies the number of ALF APSs for the PH-related stripe reference.

[0239] ph_alf_aps_id_luma[i] specifies the adaptation_parameter_set_id of the i-th ALF APS, and the luminance components of the PH-related stripes are referenced to this ALF APS.

[0240] The value of alf_luma_filter_signal_flag for the APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_alf_aps_id_luma[i] should be equal to 1.

[0241] The TemporalId of the APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_alf_aps_id_luma[i] should be less than or equal to the TemporalId of the image associated with PH.

[0242] A value of 0 for `ph_alf_chroma_idc` indicates that the adaptive loop filter is not applied to the Cb and Cr color components. A value of 1 for `ph_alf_chroma_idc` indicates that the adaptive loop filter is applied to the Cb color component. A value of 2 for `ph_alf_chroma_idc` indicates that the adaptive loop filter is applied to the Cr color component. A value of 3 for `ph_alf_chroma_idc` indicates that the adaptive loop filter is applied to both the Cb and Cr color components. When `ph_alf_chroma_idc` does not exist, it is inferred to be equal to 0.

[0243] The ph_alf_aps_id_chroma parameter specifies the adaptation_parameter_set_id of the ALF APS, and the chromaticity components of the stripes associated with PH are referenced to this ALF APS.

[0244] The value of alf_chroma_filter_signal_flag in the APS NAL unit where aps_params_type is equal to ALF_APS and adaptation_parameter_set_id is equal to ph_alf_aps_id_chroma should be equal to 1.

[0245] The TemporalId of the APS NAL unit whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_alf_aps_id_chroma should be less than or equal to the TemporalId of the image associated with PH.

[0246] A value of 1 for `ph_cc_alf_cb_enabled_flag` enables the cross-component filter for the Cb color components in all stripes associated with `PH`, and can be applied to the Cb color components within a stripe. A value of 0 for `ph_cc_alf_cb_enabled_flag` disables the cross-component filter for the Cb color components in one, several, or all stripes associated with `PH`. When it does not exist, `ph_cc_alf_cb_enabled_flag` is inferred to be equal to 0.

[0247] ph_cc_alf_cb_aps_id specifies the adaptation_parameter_set_id of the ALF APS referenced by the Cb color component of the band associated with PH.

[0248] The value of alf_cc_cb_filter_signal_flag for an APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_cc_alf_cb_aps_id should be equal to 1.

[0249] The TemporalId of an APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_cc_alf_cb_aps_id should be less than or equal to the TemporalId of the PH-related image.

[0250] A value of 1 for `ph_cc_alf_cr_enabled_flag` enables a cross-component filter for the Cr color component in all PH-related stripes, and can be applied to the Cr color component within a stripe. A value of 0 for `ph_cc_alf_cr_enabled_flag` disables the cross-component filter for the Cr color component in one, several, or all PH-related stripes. When it does not exist, `ph_cc_alf_cr_enabled_flag` is inferred to be equal to 0.

[0251] ph_cc_alf_cr_aps_id specifies the adaptation_parameter_set_id of the ALF APS referenced by the Cr color component of the band associated with PH.

[0252] The value of alf_cc_cr_filter_signal_flag for an APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_cc_alf_cr_aps_id should be equal to 1.

[0253] The TemporalId of an APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to ph_cc_alf_cr_aps_id should be less than or equal to the TemporalId of the PH-related image.

[0254] A value of 1 for ph_lmcs_enabled_flag indicates that luminance mapping with chroma scaling is enabled for all PH-related stripes. A value of 0 for ph_lmcs_enabled_flag indicates that luminance mapping with chroma scaling is disabled for one, more, or all PH-related stripes. If ph_lmcs_enabled_flag does not exist, its value is inferred to be 0.

[0255] `ph_lmcs_aps_id` specifies the `adaptation_parameter_set_id` of the LMCS APS referenced by the stripe associated with the PH. The TemporalId of the APS NAL cell whose `aps_params_type` is equal to `LMCS_APS` and whose `adaptation_parameter_set_id` is equal to `ph_lmcs_aps_id` should be less than or equal to the TemporalId of the image associated with the PH.

[0256] A ph_chroma_residual_scale_flag value of 1 enables chroma residual scaling for all stripes associated with PH. A ph_chroma_residual_scale_flag value of 0 disables chroma residual scaling for one, several, or all stripes associated with PH. When ph_chroma_residual_scale_flag does not exist, it is inferred to be equal to 0.

[0257] A value of 1 for `ph_scaling_list_present_flag` specifies that the scaling list data used for the stripes associated with the PH is derived from the scaling list data contained in the reference scaling list APS. A value of 0 for `ph_scaling_list_present_flag` specifies that the scaling list data used for the stripes associated with the PH is set to 16. When it does not exist, the value of `ph_scaling_list_present_flag` is inferred to be 0.

[0258] `ph_scaling_list_aps_id` specifies the `adaptation_parameter_set_id` of the scaling list APS. The `TemporalId` of the APS NAL cell whose `aps_params_type` is equal to `SCALING_APS` and whose `adaptation_parameter_set_id` is equal to `ph_scaling_list_aps_id` should be less than or equal to the `TemporalId` of the image associated with the PH.

[0259] `ph_virtual_boundaries_present_flag` equal to 1 specifies that information about virtual boundaries is signaled in the PH (Physical Imagery). `ph_virtual_boundaries_present_flag` equal to 0 specifies that information about virtual boundaries is not signaled in the PH. When one or more virtual boundaries are signaled in the PH, loop filtering operations across virtual boundaries in the image are disabled. Loop filtering operations include deblocking filters, sample adaptive offset filters, and adaptive loop filter operations. When not present, the value of `ph_virtual_boundaries_present_flag` is inferred to be 0.

[0260] The requirement for bitstream consistency is that when subpic_info_present_flag equals 1, the value of ph_virtual_boundaries_present_flag should equal 0.

[0261] The variable VirtualBoundariesPresentFlag is exported as follows:

[0262] VirtualBoundariesPresentFlag=0

[0263] if(sps_virtual_boundaries_enabled_flag)

[0264] VirtualBoundariesPresentFlag=sps_virtual_boundaries_present_flag||

[0265] ph_virtual_boundaries_present_flag (83)

[0266] `ph_num_ver_virtual_boundaries` specifies the number of `ph_virtual_boundaries_pos_x[i]` syntax elements present in `PH`. When `ph_num_ver_virtual_boundaries` does not exist, it is inferred to be equal to 0.

[0267] The variable NumVerVirtualBoundaries is exported as follows:

[0268] NumVerVirtualBoundaries = 0

[0269] if(sps_virtual_boundaries_enabled_flag)

[0270] NumVerVirtualBoundaries=sps_virtual_boundaries_present_flag?

[0271] sps_num_ver_virtual_boundaries:ph_num_ver_virtual_boundaries (84)

[0272] ph_virtual_boundaries_pos_x[i] specifies the position of the i-th vertical virtual boundary in units of luminance samples divided by 8. The value of ph_virtual_boundaries_pos_x[i] should be in the range of 1 to Ceil(pic_width_in_luma_samples÷8)–1 (inclusive).

[0273] The range i is a list VirtualBoundariesPosX[i] from 0 to NumVerVirtualBoundaries–1 (inclusive), in units of luminance samples, which specifies the position of the vertical virtual boundary and is derived as follows:

[0274] for(i=0; i <NumVerVirtualBoundaries;i++)

[0275] VirtualBoundariesPosX[i]=(sps_virtual_boundaries_present_flag?

[0276] sps_virtual_boundaries_pos_x[i]:ph_virtual_boundaries_pos_x[i])*8(85)

[0277] The distance between any two vertical virtual boundaries should be greater than or equal to the CtbSizeY brightness sample.

[0278] `ph_num_hor_virtual_boundaries` specifies the number of `ph_virtual_boundaries_pos_y[i]` syntax elements present in `PH`. When `ph_num_hor_virtual_boundaries` does not exist, it is inferred to be equal to 0.

[0279] The parameter NumHorVirtualBoundaries is exported as follows:

[0280] NumHorVirtualBoundaries = 0

[0281] if(sps_virtual_boundaries_enabled_flag)

[0282] NumHorVirtualBoundaries=sps_virtual_boundaries_present_flag?

[0283] sps_num_hor_virtual_boundaries:ph_num_hor_virtual_boundaries (86)

[0284] When sps_virtual_boundaries_enabled_flag equals 1 and ph_virtual_boundaries_present_flag equals 1, the sum of ph_num_ver_virtual_boundaries and ph_num_hor_virtual_boundaries should be greater than 0.

[0285] ph_virtual_boundaries_pos_y[i] specifies the position of the i-th horizontal virtual boundary in units of luminance samples divided by 8. The value of ph_virtual_boundaries_pos_y[i] should be in the range of 1 to Ceil(pic_height_in_luma_samples÷8)–1 (inclusive).

[0286] The range of i is a list of VirtualBoundariesPosY[i] from 0 to NumHorVirtualBoundaries–1 (inclusive), in units of luminance samples, which specifies the position of the horizontal virtual boundary and is derived as follows:

[0287] for(i=0; i <NumHorVirtualBoundaries;i++)

[0288] VirtualBoundariesPosY[i]=(sps_virtual_boundaries_present_flag?

[0289] sps_virtual_boundaries_pos_y[i]:ph_virtual_boundaries_pos_y[i])*8(87)

[0290] The distance between any two horizontal virtual boundaries should be greater than or equal to the CtbSizeY luminance sample.

[0291] The `pic_output_flag` affects the decoded image output and removal process, as specified in Appendix C. When `pic_output_flag` is absent, it is inferred to be equal to 1.

[0292] A partition_constraints_override_flag value of 1 indicates that the partition constraint parameters exist in the partition property (PH). A partition_constraints_override_flag value of 0 indicates that the partition constraint parameters do not exist in the PH. When they do not exist, the value of partition_constraints_override_flag is inferred to be 0.

[0293] `ph_log2_diff_min_qt_min_cb_intra_slice_luma` specifies the base-2 logarithm of the minimum size of the luminance samples of the luminance leaf blocks generated by the quadtree partitioning of the CTU, and the base-2 logarithm of the minimum decoder block size of the luminance samples of the luminance CUs in the slices with a slice_type equal to 2(I) associated with PH. The value of `ph_log2_diff_min_qt_min_cb_intra_slice_luma` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, the value of `ph_log2_diff_min_qt_min_cb_luma` is inferred to be equal to `sps_log2_diff_min_qt_min_cb_intra_slice_luma`.

[0294] `ph_max_mtt_hierarchy_depth_intra_slice_luma` specifies the maximum hierarchical depth of the encoding / decoding unit generated by multi-type tree partitioning of quad-leaf trees in stripes with a slice_type of 2(I) associated with `PH`. The value of `ph_max_mtt_hierarchy_depth_intra_slice_luma` should be in the range of 0 to 2*(CtbLog2SizeY - MinCbLog2SizeY) (inclusive). When it does not exist, the value of `ph_max_mtt_hierarchy_depth_intra_slice_luma` is inferred to be equal to `sps_max_mtt_hierarchy_depth_intra_slice_luma`.

[0295] `ph_log2_diff_max_bt_min_qt_intra_slice_luma` specifies the difference between the base-2 logarithm of the largest size (width or height) of the luminance samples in a luminance codec block that can be partitioned using binary partitioning, and the base-2 logarithm of the smallest size (width or height) of the luminance samples in a luminance leaf block resulting from a quadtree partition of a CTU in a stripe with a slice_type equal to 2(I) associated with PH. The value of `ph_log2_diff_max_bt_min_qt_intra_slice_luma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeIntraY` (inclusive). When it does not exist, the value of `ph_log2_diff_max_bt_min_qt_intra_slice_luma` is inferred to be equal to `sps_log2_diff_max_bt_min_qt_intra_slice_luma`.

[0296] `ph_log2_diff_max_tt_min_qt_intra_slice_luma` specifies the difference between the base-2 logarithm of the maximum size (width or height) of the luminance samples in a luminance codec block that can be partitioned using ternary partitioning, and the base-2 logarithm of the minimum size (width or height) of the luminance samples in a luminance leaf block resulting from a quadtree partition of a CTU in a slice with a slice_type equal to 2(I) associated with PH. The value of `ph_log2_diff_max_tt_min_qt_intra_slice_luma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeIntraY` (inclusive). When it does not exist, the value of `ph_log2_diff_max_tt_min_qt_intra_slice_luma` is inferred to be equal to `sps_log2_diff_max_tt_min_qt_intra_slice_luma`.

[0297] `ph_log2_diff_min_qt_min_cb_intra_slice_chroma` specifies the base-2 logarithm of the smallest size of the luminance samples in the chrominance leaf blocks generated by partitioning a chrominance CTU with `treeType` equal to `DUAL_TREE_CHROMA`, and the base-2 logarithm of the smallest decoder block size in the luminance samples of the chrominance CU with `treeType` equal to `DUAL_TREE_CHROMA` in the slice with `slice_type` equal to 2(I) associated with `PH`. The value of `ph_log2_diff_min_qt_min_cb_intra_slice_chroma` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, the value of ph_log2_diff_min_qt_min_cb_intra_slice_chroma is inferred to be equal to sps_log2_diff_min_qt_min_cb_intra_slice_chroma.

[0298] `ph_max_mtt_hierarchy_depth_intra_slice_chroma` specifies the maximum hierarchical depth of a chroma codec unit, which is generated by multi-type tree partitioning of chroma quadtree leaves with `treeType` equal to `DUAL_TREE_CHROMA` in a slice with `slice_type` equal to 2(I) associated with `PH`. The value of `ph_max_mtt_hierarchy_depth_intra_slice_chroma` should be in the range of 0 to 2*(CtbLog2SizeY - MinCbLog2SizeY) (inclusive). When it does not exist, the value of `ph_max_mtt_hierarchy_depth_intra_slice_chroma` is inferred to be equal to `sps_max_mtt_hierarchy_depth_intra_slice_chroma`.

[0299] `ph_log2_diff_max_bt_min_qt_intra_slice_chroma` specifies the difference between the base-2 logarithm of the largest size (width or height) of the luminance samples in a chroma codec block that can be partitioned using binary partitioning, and the base-2 logarithm of the smallest size (width or height) of the luminance samples in a chroma leaf block resulting from a quadtree partition of a chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA` from a stripe with `slice_type` equal to 2(I) associated with `PH`. The value of `ph_log2_diff_max_bt_min_qt_intra_slice_chroma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeIntraC` (inclusive). When it does not exist, the value of ph_log2_diff_max_bt_min_qt_intra_slice_chroma is inferred to be equal to sps_log2_diff_max_bt_min_qt_intra_slice_chroma.

[0300] `ph_log2_diff_max_tt_min_qt_intra_slice_chroma` specifies the base-2 logarithm of the largest size (width or height) of the luminance samples in a chroma codec block that can be partitioned using ternary partitioning, and the base-2 logarithm of the smallest size (width or height) of the luminance samples in a chroma leaf block resulting from a quadtree partition of a chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA` in a stripe with `slice_type` equal to 2(I) associated with `PH`. The value of `ph_log2_diff_max_tt_min_qt_intra_slice_chroma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeIntraC` (inclusive). When it does not exist, the value of ph_log2_diff_max_tt_min_qt_intra_slice_chroma is inferred to be equal to sps_log2_diff_max_tt_min_qt_intra_slice_chroma.

[0301] `ph_cu_qp_delta_subdiv_intra_slice` specifies the maximum `cbSubdiv` value of the codec unit in the intra-slice transmitting `cu_qp_delta_abs` and `cu_qp_delta_sign_flag`. The value of `ph_cu_qp_delta_subdiv_intra_slice` should be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+ph_max_mtt_hierarchy_depth_intra_slice_luma) (inclusive).

[0302] When it does not exist, the value of ph_cu_qp_delta_subdiv_intra_slice is inferred to be equal to 0.

[0303] `ph_cu_chroma_qp_offset_subdiv_intra_slice` specifies the maximum `cbSubdiv` value of the codec unit in the intra-slice transmitting `cu_chroma_qp_offset_flag`. The value of `ph_cu_chroma_qp_offset_subdiv_intra_slice` should be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+ph_max_mtt_hierarchy_depth_intra_slice_luma) (inclusive).

[0304] When it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_intra_slice is inferred to be equal to 0.

[0305] `ph_log2_diff_min_qt_min_cb_inter_slice` specifies the difference between the base-2 logarithm of the minimum size of the luminance samples in the luminance leaf blocks generated by the quadtree partitioning of the CTU, and the base-2 logarithm of the minimum luminance codec block size in the luminance samples of the luminance CUs in the slices with a slice_type equal to 0 (B) or 1 (P) associated with PH. The value of `ph_log2_diff_min_qt_min_cb_inter_slice` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, the value of `ph_log2_diff_min_qt_min_cb_luma` is inferred to be equal to `sps_log2_diff_min_qt_min_cb_inter_slice`.

[0306] `ph_max_mtt_hierarchy_depth_inter_slice` specifies the maximum hierarchical depth of the codec unit, which is generated by multi-type tree partitioning of quad-leaf trees in stripes with a slice_type of 0 (B) or 1 (P) associated with `PH`. The value of `ph_max_mtt_hierarchy_depth_inter_slice` should be in the range of 0 to 2*(CtbLog2SizeY - MinCbLog2SizeY) (inclusive). When it does not exist, the value of `ph_max_mtt_hierarchy_depth_inter_slice` is inferred to be equal to `sps_max_mtt_hierarchy_depth_inter_slice`.

[0307] `ph_log2_diff_max_bt_min_qt_inter_slice` specifies the base-2 logarithm of the largest size (width or height) of the luminance samples in a luminance codec block that can be divided using binary partitioning, and the base-2 logarithm of the smallest size (width or height) of the luminance samples in a luminance leaf block resulting from a quadtree partition of the CTU in a stripe with a slice_type equal to 0 (B) or 1 (P) associated with PH. The value of `ph_log2_diff_max_bt_min_qt_inter_slice` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeInterY` (inclusive). When it does not exist, the value of `ph_log2_diff_max_bt_min_qt_inter_slice` is inferred to be equal to `sps_log2_diff_max_bt_min_qt_inter_slice`.

[0308] `ph_log2_diff_max_tt_min_qt_inter_slice` specifies the difference between the base-2 logarithm of the largest size (width or height) of the luminance samples in a luminance codec block that can be partitioned using ternary partitioning, and the base-2 logarithm of the smallest size (width or height) of the luminance samples in a luminance leaf block resulting from a quadtree partition of a CTU in a stripe with a slice_type equal to 0 (B) or 1 (P) associated with PH. The value of `ph_log2_diff_max_tt_min_qt_inter_slice` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeInterY` (inclusive). When it does not exist, the value of `ph_log2_diff_max_tt_min_qt_inter_slice` is inferred to be equal to `sps_log2_diff_max_tt_min_qt_inter_slice`.

[0309] `ph_cu_qp_delta_subdiv_inter_slice` specifies the maximum `cbSubdiv` value of the codec unit for transmitting `cu_qp_delta_abs` and `cu_qp_delta_sign_flag` in the inter-frame slice. The value of `ph_cu_qp_delta_subdiv_inter_slice` should be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+ph_max_mtt_hierarchy_depth_inter_slice) (inclusive).

[0310] When it does not exist, the value of ph_cu_qp_delta_subdiv_inter_slice is inferred to be equal to 0.

[0311] `ph_cu_chroma_qp_offset_subdiv_inter_slice` specifies the maximum `cbSubdiv` value of the codec unit for transmitting `cu_chroma_qp_offset_flag` in the inter-frame slice. The value of `ph_cu_chroma_qp_offset_subdiv_inter_slice` should be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+ph_max_mtt_hierarchy_depth_inter_slice) (inclusive).

[0312] When it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_inter_slice is inferred to be equal to 0.

[0313] `ph_temporal_mvp_enabled_flag` specifies whether a temporal motion vector predictor (TVP) can be used for inter-frame prediction of the slice associated with the PH. If `ph_temporal_mvp_enabled_flag` equals 0, the syntax elements of the slice associated with the PH should be constrained so that the TVP is not used in the decoding of the slice. Otherwise (if `ph_temporal_mvp_enabled_flag` equals 1), the TVP can be used to decode the slice associated with the PH. When it does not exist, the value of `ph_temporal_mvp_enabled_flag` is inferred to be 0. The value of `ph_temporal_mvp_enabled_flag` should be 0 when there is no reference image in the DPB with the same spatial resolution as the current image.

[0314] The maximum number of MVP candidates based on sub-blocks, MaxNumSubblockMergeCand, is derived as follows:

[0315]

[0316]

[0317] The value of MaxNumSubblockMergeCand should be in the range of 0 to 5 (inclusive).

[0318] A value of 1 for ph_collocated_from_l0_flag specifies that the co-located image used for temporal motion vector prediction is derived from reference image list 0. A value of 0 for ph_collocated_from_l0_flag specifies that the co-located image used for temporal motion vector prediction is derived from reference image list 1.

[0319] ph_collocated_ref_idx specifies the reference index of the co-located image used for temporal motion vector prediction.

[0320] When ph_collocated_from_l0_flag equals 1, ph_collocated_ref_idx references the entry in reference image list 0, and the value of ph_collocated_ref_idx should be in the range of 0 to num_ref_entries[0][RplsIdx[0]]–1 (inclusive).

[0321] When ph_collocated_from_l0_flag equals 0, ph_collocated_ref_idx references the entry in reference image list 1, and the value of ph_collocated_ref_idx should be in the range of 0 to num_ref_entries[1][RplsIdx[1]]-1 (inclusive).

[0322] When it does not exist, the value of ph_collocated_ref_idx is inferred to be equal to 0.

[0323] A `mvd_l1_zero_flag` value of 1 indicates that the `mvd_coding(x0,y0,1)` syntax structure is not parsed, and for `compIdx = 0..1` and `cpIdx = 0..2`, `MvdL1[x0][y0][compIdx]` and `MvdCpL1[x0][y0][cpIdx][compIdx]` are set to 0. A `mvd_l1_zero_flag` value of 0 indicates that the `mvd_coding(x0,y0,1)` syntax structure is parsed.

[0324] A value of 1 for `ph_fpel_mmvd_enabled_flag` specifies that merge mode with motion vector difference uses integer sample precision in the strips associated with PH. A value of 0 for `ph_fpel_mmvd_enabled_flag` specifies that merge mode with motion vector difference can use fractional sample precision in the strips associated with PH. When it does not exist, the value of `ph_fpel_mmvd_enabled_flag` is inferred to be 0.

[0325] A value of 1 for ph_disable_bdof_flag disables inter-frame bidirectional prediction based on bidirectional optical flow in the stripe associated with the PH. A value of 0 for ph_disable_bdof_flag enables or disables inter-frame bidirectional prediction based on bidirectional optical flow in the stripe associated with the PH.

[0326] The following applies when ph_disable_bdof_flag is not present:

[0327] --If sps_bdof_enabled_flag equals 1, then it is inferred that the value of ph_disable_bdof_flag is equal to 0.

[0328] --Otherwise (sps_bdof_enabled_flag equals 0), the value of ph_disable_bdof_flag is inferred to be equal to 1.

[0329] A value of 1 for ph_disable_dmvr_flag disables inter-frame bidirectional prediction based on decoder motion vector refinement in the stripe associated with the PH. A value of 0 for ph_disable_dmvr_flag enables or disables inter-frame bidirectional prediction based on decoder motion vector refinement in the stripe associated with the PH.

[0330] The following applies when ph_disable_dmvr_flag is not present:

[0331] --If sps_dmvr_enabled_flag equals 1, then the value of ph_disable_dmvr_flag is inferred to be equal to 0.

[0332] --Otherwise (sps_dmvr_enabled_flag equals 0), the value of ph_disable_dmvr_flag is inferred to be equal to 1.

[0333] A value of 1 for ph_disable_prof_flag disables optical flow prediction refinement in the stripe associated with PH. A value of 0 for ph_disable_prof_flag enables or disables optical flow prediction refinement in the stripe associated with PH.

[0334] The following applies when ph_disable_prof_flag is not present:

[0335] --If sps_affine_prof_enabled_flag equals 1, then the value of ph_disable_prof_flag is inferred to be equal to 0.

[0336] --Otherwise (sps_affine_prof_enabled_flag equals 0), the value of ph_disable_prof_flag is inferred to be equal to 1.

[0337] ph_qp_delta specifies the Qp used for codec blocks in an image. Y The initial value remains unchanged until it is modified by the value of CuQpDeltaVal in the codec unit layer.

[0338] When qp_delta_info_in_ph_flag equals 1, the Qp of all bands in the image Y Initial value of quantization parameter SliceQp Y The following was exported:

[0339] SliceQp Y=26+init_qp_minus26+ph_qp_delta (89)

[0340] SliceQp Y The value should be in the range of -QpBdOffset to +63 (inclusive).

[0341] `ph_joint_cbcr_sign_flag` specifies whether the co-located residual samples of the two chromaticity components have inverted signs in a transform unit where `tu_joint_cbcr_residual_flag[x0][y0]` equals 1. When `tu_joint_cbcr_residual_flag[x0][y0]` equals 1 for the transform unit, `ph_joint_cbcr_sign_flag` equals 0, indicating that the sign of each residual sample of the Cr (or Cb) component is the same as the sign of the co-located Cb (or Cr) residual sample, and `ph_joint_cbcr_sign_flag` equals 1, indicating that the sign of each residual sample of the Cr (or Cb) component is given by the inverted sign of the co-located Cb (or Cr) residual sample.

[0342] A value of 1 for ph_sao_luma_enabled_flag indicates that SAO is enabled for the luminance component in all stripes associated with PH; a value of 0 for ph_sao_luma_enabled_flag indicates that SAO for the luminance component can be disabled for one, more, or all stripes associated with PH. When ph_sao_luma_enabled_flag does not exist, it is inferred to be equal to 0.

[0343] A value of 1 for ph_sao_chroma_enabled_flag indicates that SAO is enabled for the chromaticity components in all stripes associated with PH; a value of 0 for ph_sao_chroma_enabled_flag indicates that SAO for the chromaticity components can be disabled for one, more, or all stripes associated with PH. When ph_sao_chroma_enabled_flag does not exist, it is inferred to be equal to 0.

[0344] A value of 0 for `ph_dep_quant_enabled_flag` disables dependency quantization for the current image. A value of 1 for `ph_dep_quant_enabled_flag` enables dependency quantization for the current image. When `ph_dep_quant_enabled_flag` does not exist, it is inferred to be equal to 0.

[0345] A value of 0 for `pic_sign_data_hiding_enabled_flag` disables sign bit hiding for the current image. A value of 1 for `pic_sign_data_hiding_enabled_flag` enables sign bit hiding for the current image. When `pic_sign_data_hiding_enabled_flag` does not exist, it is inferred to be equal to 0.

[0346] A value of 1 for `ph_deblocking_filter_override_flag` indicates that the deblocking parameter exists in the PH (Physical Deblocking Filter). A value of 0 for `ph_deblocking_filter_override_flag` indicates that the deblocking parameter does not exist in the PH. When it does not exist, the value of `ph_deblocking_filter_override_flag` is inferred to be 0.

[0347] A value of 1 for `ph_deblocking_filter_disabled_flag` indicates that the deblocking filter operation does not apply to stripes associated with pH. A value of 0 for `ph_deblocking_filter_disabled_flag` indicates that the deblocking filter operation applies to stripes associated with pH. When `ph_deblocking_filter_disabled_flag` does not exist, it is inferred to be equal to `pps_deblocking_filter_disabled_flag`.

[0348] `ph_beta_offset_div2` and `ph_tc_offset_div2` specify the deblocking parameter offsets for β and tC (divided by 2), which are applied to the luminance component of the strip associated with PH. The values ​​of both `ph_beta_offset_div2` and `ph_tc_offset_div2` should be in the range of -12 to 12 (inclusive). When not present, the values ​​of `ph_beta_offset_div2` and `ph_tc_offset_div2` are inferred to be equal to `pps_beta_offset_div2` and `pps_tc_offset_div2`, respectively.

[0349] `ph_cb_beta_offset_div2` and `ph_cb_tc_offset_div2` specify the deblocking parameter offsets for β and tC (divided by 2), which are applied to the Cb component of the stripe associated with PH. The values ​​of both `ph_cb_beta_offset_div2` and `ph_cb_tc_offset_div2` should be in the range of -12 to 12 (inclusive). When not present, the values ​​of `ph_cb_beta_offset_div2` and `ph_cb_tc_offset_div2` are inferred to be equal to `pps_cb_beta_offset_div2` and `pps_cb_tc_offset_div2`, respectively.

[0350] `ph_cr_beta_offset_div2` and `ph_cr_tc_offset_div2` specify the deblocking parameter offsets for β and tC (divided by 2), which are applied to the Cr component of the strip associated with PH. The values ​​of both `ph_cr_beta_offset_div2` and `ph_cr_tc_offset_div2` should be in the range of -12 to 12 (inclusive). When not present, the values ​​of `ph_cr_beta_offset_div2` and `ph_cr_tc_offset_div2` are inferred to be equal to `pps_cr_beta_offset_div2` and `pps_cr_tc_offset_div2`, respectively.

[0351] `ph_extension_length` specifies the length of the PH extension data in bytes, excluding the bits used for signaling notification of `ph_extension_length` itself. The value of `ph_extension_length` should be in the range of 0 to 256 (inclusive). If it does not exist, the value of `ph_extension_length` is inferred to be equal to 0.

[0352] `ph_extension_data_byte` can be any value. Decoders conforming to this version of the specification should ignore the value of `ph_extension_data_byte`. Its value does not affect the consistency of the decoder with the grade specified in this version of the specification.

[0353] 3.3.SH Syntax and Semantics

[0354] In the latest VVC draft text, the SH syntax and semantics are as follows:

[0355]

[0356]

[0357]

[0358]

[0359]

[0360] The variable CuQpDeltaVal, which specifies the difference between the luminance quantization parameter and its prediction for the codec unit containing cu_qp_delta_abs, is set to 0. It is also specified that the Qp′ of the codec unit containing cu_chroma_qp_offset_flag is determined... Cb Qp′ Cr and Qp′ CbCr The variable CuQpOffset is used to determine the value of the quantized parameter. Cb CuQpOffset Cr and CuQpOffset CbCr All of them were set to 0.

[0361] A picture_header_in_slice_header_flag value of 1 indicates that the PH syntax structure exists in the slice header. A picture_header_in_slice_header_flag value of 0 indicates that the PH syntax structure does not exist in the slice header.

[0362] The requirement for bitstream consistency is that the value of picture_header_in_slice_header_flag should be the same in all codec slices in CLVS.

[0363] When picture_header_in_slice_header_flag is equal to 1 for the codec slice, the requirement for bitstream consistency is that there should be no VCL NAL unit in CLVS with nal_unit_type equal to PH_NUT.

[0364] When picture_header_in_slice_header_flag equals 0, all encoded and decoded stripes in the current image should have picture_header_in_slice_header_flag equal to 0, and the current PU should have PH NAL units.

[0365] `slice_subpic_id` specifies the subpick ID of the subpick containing the slice. If `slice_subpic_id` exists, the value of the variable `CurrSubpicIdx` is exported such that `SubpicIdVal[CurrSubpicIdx]` equals `slice_subpic_id`. Otherwise (if `slice_subpic_id` does not exist), `CurrSubpicIdx` is exported as 0. The length of `slice_subpic_id` is `sps_subpic_id_len_minus1+1` bits.

[0366] `slice_address` specifies the address of the slice. When it does not exist, the value of `slice_address` is inferred to be 0. When `rect_slice_flag` is equal to 1 and `NumSlicesInSubpic[CurrSubpicIdx]` is equal to 1, the value of `slice_address` is inferred to be 0.

[0367] If rect_slice_flag equals 0, then the following applies:

[0368] --The stripe address is the raster scan stripe index.

[0369] The length of `--slice_address` is `Ceil(Log2(NumTilesInPic))` bits.

[0370] The value of --slice_address should be in the range of 0 to NumTilesInPic–1 (inclusive).

[0371] Otherwise (rect_slice_flag equals 1), the following applies:

[0372] --The stripe address is the sub-image level stripe index of the stripe.

[0373] The length of `--slice_address` is `Ceil(Log2(NumSlicesInSubpic[CurrSubpicIdx]))` bits.

[0374] The value of --slice_address should be in the range of 0 to NumSlicesInSubpic[CurrSubpicIdx]–1 (inclusive).

[0375] Bitstream consistency requirements are based on the following constraints:

[0376] --If rect_slice_flag is equal to 0 or subpic_info_present_flag is equal to 0, then the value of slice_address should not be equal to the value of slice_address of any other codec strip NAL unit of the same codec image.

[0377] --Otherwise, a pair of slice_subpic_id and slice_address values ​​should not be equal to a pair of slice_subpic_id and slice_address values ​​for any other codec strip NAL unit of the same codec image.

[0378] --The shape of the image stripes should be such that, when each CTU is being decoded, its entire left edge and entire top edge should consist of the image boundary or the boundaries of the previously decoded (multiple) CTUs.

[0379] sh_extra_bit[i] can be equal to 1 or 0. Decoders conforming to this version of the specification should ignore the value of sh_extra_bit[i]. Its value does not affect the consistency of the decoder with the grade specified in this version of the specification.

[0380] The increment of 1 in num_tiles_in_slice_minus1 (if present) specifies the number of slices in the strip. The value of num_tiles_in_slice_minus1 should be in the range of 0 to NumTilesInPic–1 (inclusive).

[0381] The variable NumCtusInCurrSlice specifies the number of CTUs in the current slice, and i ranges from 0 to a list of NumCtusInCurrSlice–1 (inclusive). CtbAddrInCurrSlice[i] specifies the raster scan address of the i-th CTU within the slice, derived as follows:

[0382]

[0383] The variables SubpicLeftBoundaryPos, SubpicTopBoundaryPos, SubpicRightBoundaryPos, and SubpicBotBoundaryPos are derived as follows:

[0384]

[0385]

[0386] slice_type specifies the encoding / decoding type of the slice according to Table 9.

[0387] Table 9 – Name association with slice_type

[0388] slice_type The name of slice_type 0 B (B band) 1 P (P-band) 2 I(I strip)

[0389] When it does not exist, the value of slice_type is inferred to be equal to 2.

[0390] When ph_intra_slice_allowed_flag equals 0, the value of slice_type should be 0 or 1. When nal_unit_type is in the range from IDR_W_RADL to CRA_NUT (inclusive) and vps_independent_layer_flag[GeneralLayerIdx[nuh_layer_id]] equals 1, slice_type should be 2.

[0391] The variables MinQtLog2SizeY, MinQtLog2SizeC, MinQtSizeY, MinQtSizeC, MaxBtSizeY, MaxBtSizeC, MinBtSizeY, MaxTtSizeY, MaxTtSizeC, MinTtSizeY, MaxMttDepthY, and MaxMttDepthC are derived as follows:

[0392] --If slice_type equals 2(I), then the following applies:

[0393] MinQtLog2SizeY=MinCbLog2SizeY+ph_log2_diff_min_qt_min_cb_intra_slice_luma (119)

[0394] MinQtLog2SizeC=MinCbLog2SizeY+ph_log2_diff_min_qt_min_cb_intra_slice_chroma (120)

[0395] MaxBtSizeY=1<<(MinQtLog2SizeY+ph_log2_diff_max_bt_min_qt_intra_slice_luma) (121)

[0396] MaxBtSizeC=1<<(MinQtLog2SizeC+ph_log2_diff_max_bt_min_qt_intra_slice_chroma) (122)

[0397] MaxTtSizeY = 1 << (MinQtLog2SizeY + ph_log2_diff_max_tt_min_qt_intra_slice_luma) (123)

[0398] MaxTtSizeC = 1 << (MinQtLog2SizeC + ph_log2_diff_max_tt_min_qt_intra_slice_chroma) (124)

[0399] MaxMttDepthY = ph_max_mtt_hierarchy_depth_intra_slice_luma (125)

[0400] MaxMttDepthC = ph_max_mtt_hierarchy_depth_intra_slice_chroma (126)

[0401] CuQpDeltaSubdiv = ph_cu_qp_delta_subdiv_intra_slice (127)

[0402] CuChromaQpOffsetSubdiv = ph_cu_chroma_qp_offset_subdiv_intra_slice(128)

[0403] -- Otherwise (slice_type equals 0 (B) or 1 (P)), the following applies:

[0404] MinQtLog2SizeY = MinCbLog2SizeY + ph_log2_diff_min_qt_min_cb_inter_slice(129)

[0405] MinQtLog2SizeC = MinCbLog2SizeY + ph_log2_diff_min_qt_min_cb_inter_slice(130)

[0406] MaxBtSizeY = 1 << (MinQtLog2SizeY + ph_log2_diff_max_bt_min_qt_inter_slice) (131)

[0407] MaxBtSizeC = 1 << (MinQtLog2SizeC + ph_log2_diff_max_bt_min_qt_inter_slice) (132)

[0408] MaxTtSizeY = 1 << (MinQtLog2SizeY + ph_log2_diff_max_tt_min_qt_inter_slice) (133)

[0409] MaxTtSizeC = 1 << (MinQtLog2SizeC + ph_log2_diff_max_tt_min_qt_inter_slice) (134)

[0410] MaxMttDepthY = ph_max_mtt_hierarchy_depth_inter_slice (135)

[0411] MaxMttDepthC = ph_max_mtt_hierarchy_depth_inter_slice (136)

[0412] CuQpDeltaSubdiv = ph_cu_qp_delta_subdiv_inter_slice (137)

[0413] CuChromaQpOffsetSubdiv = ph_cu_chroma_qp_offset_subdiv_inter_slice(138)

[0414] -- The following applies:

[0415] MinQtSizeY = 1 << MinQtLog2SizeY (139)

[0416] MinQtSizeC = 1 << MinQtLog2SizeC (140)

[0417] MinBtSizeY = 1 << MinCbLog2SizeY (141)

[0418] MinTtSizeY = 1 << MinCbLog2SizeY (142)

[0419] A slice_alf_enabled_flag value of 1 indicates that the adaptive loop filter is enabled and can be applied to the Y, Cb, or Cr color components in the slice. A slice_alf_enabled_flag value of 0 indicates that the adaptive loop filter is disabled for all color components in the slice. When it does not exist, the value of slice_alf_enabled_flag is inferred to be equal to ph_alf_enabled_flag.

[0420] `slice_num_alf_aps_ids_luma` specifies the number of ALF APS referenced by the slice. When `slice_alf_enabled_flag` is equal to 1 and `slice_num_alf_aps_ids_luma` does not exist, the value of `slice_num_alf_aps_ids_luma` is inferred to be equal to the value of `ph_num_alf_aps_ids_luma`.

[0421] `slice_alf_aps_id_luma[i]` specifies the `adaptation_parameter_set_id` of the i-th ALF APS referenced by the luminance component of the slice. The `temporalId` of the APS NAL unit where `aps_params_type` equals `ALF_APS` and `adaptation_parameter_set_id` equals `slice_alf_aps_id_luma[i]` should be less than or equal to the `temporalId` of the NAL unit of the codec slice. When `slice_alf_enabled_flag` equals 1 and `slice_alf_aps_id_luma[i]` does not exist, the value of `slice_alf_aps_id_luma[i]` is inferred to be equal to the value of `ph_alf_aps_id_luma[i]`.

[0422] The value of alf_luma_filter_signal_flag for the APS NAL cell where aps_params_type is equal to ALF_APS and adaptation_parameter_set_id is equal to slice_alf_aps_id_luma[i] should be equal to 1.

[0423] A slice_alf_chroma_idc equal to 0 indicates that the adaptive loop filter is not applied to the Cb and Cr color components. A slice_alf_chroma_idc equal to 1 indicates that the adaptive loop filter is applied to the Cb color component. A slice_alf_chroma_idc equal to 2 indicates that the adaptive loop filter is applied to the Cr color component. A slice_alf_chroma_idc equal to 3 indicates that the adaptive loop filter is applied to both the Cb and Cr color components. When slice_alf_chroma_idc does not exist, it is inferred to be equal to ph_alf_chroma_idc.

[0424] `slice_alf_aps_id_chroma` specifies the `adaptation_parameter_set_id` of the ALF APS referenced by the chroma components of the slice. The `temporalId` of the APS NAL unit where `aps_params_type` equals `ALF_APS` and `adaptation_parameter_set_id` equals `slice_alf_aps_id_chroma` should be less than or equal to the `temporalId` of the NAL unit of the codec slice. When `slice_alf_enabled_flag` equals 1 and `slice_alf_aps_id_chroma` does not exist, the value of `slice_alf_aps_id_chroma` is inferred to be equal to the value of `ph_alf_aps_id_chroma`.

[0425] The value of alf_chroma_filter_signal_flag in the APS NAL cell where aps_params_type is equal to ALF_APS and adaptation_parameter_set_id is equal to slice_alf_aps_id_chroma should be equal to 1.

[0426] A slice_cc_alf_cb_enabled_flag value of 0 indicates that the cross-component filter is not applied to the Cb color component. A slice_cc_alf_cb_enabled_flag value of 1 indicates that the cross-component filter is enabled and can be applied to the Cb color component. When slice_cc_alf_cb_enabled_flag does not exist, it is inferred to be equal to ph_cc_alf_cb_enabled_flag.

[0427] slice_cc_alf_cb_aps_id specifies the adaptation_parameter_set_id referenced by the Cb color component of the stripe.

[0428] The TemporalId of the APS NAL unit whose aps_params_type equals ALF_APS and whose adaptation_parameter_set_id equals slice_cc_alf_cb_aps_id should be less than or equal to the TemporalId of the codec slice NAL unit. When slice_cc_alf_cb_enabled_flag equals 1 and slice_cc_alf_cb_aps_id does not exist, the value of slice_cc_alf_cb_aps_id is inferred to be equal to the value of ph_cc_alf_cb_aps_id.

[0429] The value of alf_cc_cb_filter_signal_flag for the APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to slice_cc_alf_cb_aps_id should be equal to 1.

[0430] A slice_cc_alf_cr_enabled_flag value of 0 indicates that the cross-component filter is not applied to the Cr color component. A slice_cc_alf_cb_enabled_flag value of 1 indicates that the cross-component adaptive loop filter is enabled and can be applied to the Cr color component. When slice_cc_alf_cr_enabled_flag does not exist, it is inferred to be equal to ph_cc_alf_cr_enabled_flag.

[0431] `slice_cc_alf_cr_aps_id` specifies the `adaptation_parameter_set_id` referenced by the Cr color component of the slice. The `TemporalId` of the APS NAL unit where `aps_params_type` equals `ALF_APS` and `adaptation_parameter_set_id` equals `slice_cc_alf_cr_aps_id` should be less than or equal to the `TemporalId` of the NAL unit of the codec slice. When `slice_cc_alf_cr_enabled_flag` equals 1 and `slice_cc_alf_cr_aps_id` does not exist, the value of `slice_cc_alf_cr_aps_id` is inferred to be equal to the value of `ph_cc_alf_cr_aps_id`.

[0432] The value of alf_cc_cr_filter_signal_flag for an APS NAL cell whose aps_params_type is equal to ALF_APS and whose adaptation_parameter_set_id is equal to slice_cc_alf_cr_aps_id should be equal to 1.

[0433] When separate_colour_plane_flag equals 1, colour_plane_id identifies the color plane associated with the current stripe. The value of colour_plane_id should be in the range of 0 to 2 (inclusive). colour_plane_id values ​​0, 1, and 2 correspond to the Y, Cb, and Cr planes, respectively. The value of colour_plane_id 3 is reserved for future use by ITU-T|ISO / IEC.

[0434] Note 1 – There is no dependency between the decoding processes of different color planes of an image.

[0435] A value of 1 for num_ref_idx_active_override_flag indicates that the syntax element num_ref_idx_active_minus1[0] exists in both P and B stripes, and that the syntax element num_ref_idx_active_minus1[1] exists in B stripe. A value of 0 for num_ref_idx_active_override_flag indicates that neither num_ref_idx_active_minus1[0] nor num_ref_idx_active_minus1[1] exists. When num_ref_idx_active_override_flag is not present, its value is inferred to be 1.

[0436] num_ref_idx_active_minus1[i] is used to derive the variable NumRefIdxActive[i], as specified in Equation 143. The value of num_ref_idx_active_minus1[i] should be in the range of 0 to 14 (inclusive).

[0437] For i equal to 0 or 1, when the current stripe is a B stripe, num_ref_idx_active_override_flag equals 1, and num_ref_idx_active_minus1[i] does not exist, num_ref_idx_active_minus1[i] is inferred to be equal to 0.

[0438] When the current stripe is a P stripe, num_ref_idx_active_override_flag is equal to 1, and num_ref_idx_active_minus1[0] does not exist, num_ref_idx_active_minus1[0] is inferred to be equal to 0.

[0439] The variable NumRefIdxActive[i] is derived as follows:

[0440]

[0441] The value of NumRefIdxActive[i]-1 specifies the maximum reference index of the reference image list i that can be used to decode the strip. When the value of NumRefIdxActive[i] is equal to 0, no reference index of the reference image list i can be used to decode the strip.

[0442] When the current stripe is a P stripe, the value of NumRefIdxActive[0] should be greater than 0.

[0443] When the current stripe is a B stripe, both NumRefIdxActive[0] and NumRefIdxActive[1] should be greater than 0.

[0444] `cabac_init_flag` specifies the method used to determine the initialization table used during the initialization of context variables. When `cabac_init_flag` does not exist, it is inferred to be equal to 0.

[0445] A slice_collocated_from_l0_flag value of 1 specifies that the co-located image used for temporal motion vector prediction is derived from reference image list 0. A slice_collocated_from_l0_flag value of 0 specifies that the co-located image used for temporal motion vector prediction is derived from reference image list 1.

[0446] When slice_type equals B or P, ph_temporal_mvp_enabled_flag equals 1, and slice_collocated_from_l0_flag does not exist, the following applies:

[0447] --If rpl_info_in_ph_flag equals 1, then it is inferred that slice_collocated_from_l0_flag equals ph_collocated_from_l0_flag.

[0448] --Otherwise (rpl_info_in_ph_flag equals 0 and slice_type equals P), the value of slice_collocated_from_l0_flag is inferred to be equal to 1.

[0449] The slice_collocated_ref_idx specifies the reference index of the co-located image used for temporal motion vector prediction.

[0450] When slice_type equals P or when slice_type equals B and slice_collocated_from_l0_flag equals 1, slice_collocated_ref_idx references the entry in reference image list 0, and the value of slice_collocated_ref_idx should be in the range of 0 to NumRefIdxActive[0]–1 (inclusive).

[0451] When slice_type equals B and slice_collocated_from_l0_flag equals 0, slice_collocated_ref_idx references the entry in reference image list 1, and the value of slice_collocated_ref_idx should be in the range of 0 to NumRefIdxActive[1]–1 (inclusive).

[0452] The following applies when slice_collocated_ref_idx does not exist:

[0453] --If rpl_info_in_ph_flag equals 1, then it is inferred that the value of slice_collocated_ref_idx is equal to ph_collocated_ref_idx.

[0454] --Otherwise (rpl_info_in_ph_flag equals 0), the value of slice_collocated_ref_idx is inferred to be equal to 0.

[0455] The requirement for bitstream consistency is that the image referenced by slice_collocated_ref_idx should be identical across all slices of the encoded / decoded image.

[0456] The requirement for bitstream consistency is that the values ​​of pic_width_in_luma_samples and pic_height_in_luma_samples of the reference image referenced by slice_collocated_ref_idx should be equal to the values ​​of pic_width_in_luma_samples and pic_height_in_luma_samples of the current image, respectively, and RprConstraintsActive[slice_collocated_from_l0_flag? 0:1][slice_collocated_ref_idx] should be equal to 0.

[0457] slice_qp_delta specifies the Qp used for codec blocks in a slice. Y The initial value remains unchanged until it is modified by the value of CuQpDeltaVal in the codec unit layer.

[0458] When qp_delta_info_in_ph_flag equals 0, the Qp of the stripe Y Initial value of quantization parameter SliceQp Y The following was exported:

[0459] SliceQp Y =26+init_qp_minus26+slice_qp_delta (144)

[0460] SliceQp Y The value should be in the range of -QpBdOffset to +63 (inclusive).

[0461] When any of the following conditions are true:

[0462] The values ​​of --wp_info_in_ph_flag, pps_weighted_pred_flag, and slice_type are all equal to 1.

[0463] The values ​​of --wp_info_in_ph_flag, pps_weighted_bipred_flag, and slice_type are all equal to 1 and B, respectively.

[0464] The following applies:

[0465] The value of --NumRefIdxActive[0] should be less than or equal to the value of NumWeightsL0.

[0466] – For each reference image index RefPicList[0][i] in the range of i from 0 to NumRefIdxActive[0]-1 (inclusive), the luminance weight, Cb weight and Cr weight applied to the reference image index are LumaWeightL0[i], ChromaWeightL0[0][i] and ChromaWeightL0[1][i], respectively.

[0467] When wp_info_in_ph_flag equals 1, pps_weighted_bipred_flag equals 1, and slice_type equals B, the following applies:

[0468] The value of --NumRefIdxActive[1] should be less than or equal to the value of NumWeightsL1.

[0469] – For each reference image index RefPicList[1][i] in the range of i from 0 to NumRefIdxActive[1]-1 (inclusive), the luminance weight, Cb weight and Cr weight applied to the reference image index are LumaWeightL1[i], ChromaWeightL1[0][i] and ChromaWeightL1[1][i], respectively.

[0470] slice_cb_qp_offset specifies the offset when determining Qp′ CbThe value of the quantization parameter should be added to the difference between the values ​​of pps_cb_qp_offset and pps_cb_qp_offset. The value of slice_cb_qp_offset should be in the range of -12 to +12 (inclusive). If slice_cb_qp_offset does not exist, it is inferred to be equal to 0. The value of pps_cb_qp_offset + slice_cb_qp_offset should be in the range of -12 to +12 (inclusive).

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

[0472] slice_joint_cbcr_qp_offset specifies the offset when determining Qp′ CbCr The value should be added to the difference between the values ​​of `pps_joint_cbcr_qp_offset_value` and `slice_joint_cbcr_qp_offset`. The value of `slice_joint_cbcr_qp_offset` should be in the range of -12 to +12 (inclusive). When `slice_joint_cbcr_qp_offset` does not exist, it is inferred to be equal to 0. The value of `pps_joint_cbcr_qp_offset_value + slice_joint_cbcr_qp_offset` should be in the range of -12 to +12 (inclusive).

[0473] A value of 1 for `cu_chroma_qp_offset_enabled_flag` indicates that `cu_chroma_qp_offset_flag` can exist in the transform unit and the palette codec syntax. A value of 0 for `cu_chroma_qp_offset_enabled_flag` indicates that `cu_chroma_qp_offset_flag` does not exist in either the transform unit or the palette codec syntax. When it does not exist, the value of `cu_chroma_qp_offset_enabled_flag` is inferred to be 0.

[0474] A slice_sao_luma_flag value of 1 indicates that SAO is enabled for the luminance component in the current slice; a slice_sao_luma_flag value of 0 indicates that SAO is disabled for the luminance component in the current slice. When slice_sao_luma_flag does not exist, it is inferred to be equal to ph_sao_luma_enabled_flag.

[0475] A slice_sao_chroma_flag value of 1 indicates that SAO is enabled for the chroma components in the current slice; a slice_sao_chroma_flag value of 0 indicates that SAO is disabled for the chroma components in the current slice. When slice_sao_chroma_flag does not exist, it is inferred to be equal to ph_sao_chroma_enabled_flag.

[0476] A slice_deblocking_filter_override_flag value of 1 indicates that the deblocking parameters are present in the slice header. A slice_deblocking_filter_override_flag value of 0 indicates that the deblocking parameters are not present in the slice header. When the deblocking parameters are not present, the value of slice_deblocking_filter_override_flag is inferred to be equal to ph_deblocking_filter_override_flag.

[0477] A slice_deblocking_filter_disabled_flag value of 1 indicates that the deblocking filter operation should not be applied to the current slice. A slice_deblocking_filter_disabled_flag value of 0 indicates that the deblocking filter operation should be applied to the current slice. When slice_deblocking_filter_disabled_flag does not exist, it is inferred to be equal to ph_deblocking_filter_disabled_flag.

[0478] `slice_beta_offset_div2` and `slice_tc_offset_div2` specify the deblocking parameter offsets applied to the luminance component of the current slice, β and tC (divided by 2). The values ​​of both `slice_beta_offset_div2` and `slice_tc_offset_div2` should be in the range of -12 to 12 (inclusive). When not present, the values ​​of `slice_beta_offset_div2` and `slice_tc_offset_div2` are inferred to be equal to `ph_beta_offset_div2` and `ph_tc_offset_div2`, respectively.

[0479] `slice_cb_beta_offset_div2` and `slice_cb_tc_offset_div2` specify the deblocking parameter offsets applied to the Cb components of the current slice, β and tC (divided by 2). The values ​​of both `slice_cb_beta_offset_div2` and `slice_cb_tc_offset_div2` should be in the range of -12 to 12 (inclusive). When not present, the values ​​of `slice_cb_beta_offset_div2` and `slice_cb_tc_offset_div2` are inferred to be equal to `ph_cb_beta_offset_div2` and `ph_cb_tc_offset_div2`, respectively.

[0480] `slice_cb_beta_offset_div2` and `slice_cb_tc_offset_div2` specify the deblocking parameter offsets for β and tC (divided by 2) applied to the Cr component of the current slice. The values ​​of `slice_cr_beta_offset_div2` and `slice_cr_tc_offset_div2` should both be in the range of -12 to 12 (inclusive). When not present, the values ​​of `slice_cr_beta_offset_div2` and `slice_cr_tc_offset_div2` are inferred to be equal to `ph_cr_beta_offset_div2` and `ph_cr_tc_offset_div2`, respectively.

[0481] A slice_ts_residual_coding_disabled_flag value of 1 specifies that the residual_coding() syntax structure is used to parse the residual samples of the transform skipped blocks of the current slice. A slice_ts_residual_coding_disabled_flag value of 0 specifies that the residual_ts_coding() syntax structure is used to parse the residual samples of the transform skipped blocks of the current slice. When slice_ts_residual_coding_disabled_flag does not exist, it is inferred to be equal to 0.

[0482] A slice_lmcs_enabled_flag value of 1 indicates that luma mapping with chroma scaling is enabled for the current slice. A slice_lmcs_enabled_flag value of 0 indicates that luma mapping with chroma scaling is not enabled for the current slice. When slice_lmcs_enabled_flag does not exist, it is inferred to be equal to 0.

[0483] A slice_scaling_list_present_flag value of 1 indicates that the scaling list data used for the current slice is derived from the scaling list data contained in the reference scaling list APS, where aps_params_type equals SCALING_APS and adaptation_parameter_set_id equals ph_scaling_list_aps_id. A slice_scaling_list_present_flag value of 0 indicates that the scaling list data used for the current image is the default scaling list data specified in Clause 7.4.3.21. When it does not exist, the value of slice_scaling_list_present_flag is inferred to be equal to 0.

[0484] The variable NumEntryPoints specifies the number of entry points in the current strip, derived as follows:

[0485]

[0486] Increasing 1 to offset_len_minus1 specifies the length in bits of the entry_point_offset_minus1[i] syntax element. The value of offset_len_minus1 should be in the range of 0 to 31 (inclusive).

[0487] The offset of the i-th entry point is specified by incrementing 1 by entry_point_offset_minus1[i] in bytes and is represented by offset_len_minus1 plus 1 bit. The strip data following the strip header consists of NumEntryPoints+1 subsets, where the subset index values ​​range from 0 to NumEntryPoints (inclusive). The first byte of the strip data is considered byte 0. When present, simulations appearing in the strip data portion of the NAL unit of the codec strip prevent bytes from being counted as part of the strip data for subset identification purposes. Subset 0 consists of bytes 0 to entry_point_offset_minus1[0] (inclusive) of the codec strip data, and subset k (where k ranges from 1 to NumEntryPoints-1 (inclusive)) consists of bytes firstByte[k] to lastByte[k] (inclusive) of the codec strip data, where firstByte[k] and lastByte[k] are defined as:

[0488]

[0489] lastByte[k]=firstByte[k]+entry_point_offset_minus1[k] (147)

[0490] The last subset (where the subset index equals NumEntryPoints) consists of the remaining bytes of the encoded and decoded stripe data.

[0491] When sps_entropy_coding_sync_enabled_flag equals 0 and the stripe contains one or more complete slices, each subset should consist of all the codec bits of all CTUs in the stripe within the same slice, and the number of subsets (i.e., the value of NumEntryPoints+1) should be equal to the number of slices in the stripe.

[0492] When `sps_entropy_coding_sync_enabled_flag` equals 0 and the slice contains a subset of CTU rows from a single slice, `NumEntryPoints` should be 0, and the number of subsets should be 1. This subset should consist of all the codec bits for all CTUs in the slice.

[0493] When sps_entropy_coding_sync_enabled_flag equals 1, each subset k in the range of 0 to NumEntryPoints (inclusive) should consist of all the codec bits of all CTUs in the CTU line within the slice, and the number of subsets (i.e., the value of NumEntryPoints+1) should be equal to the total number of slice-specific CTU lines in the stripe.

[0494] `slice_header_extension_length` specifies the length of the slice header extension data in bytes, excluding the bits used for signaling notifications within `slice_header_extension_length` itself. The value of `slice_header_extension_length` should be in the range of 0 to 256 (inclusive). If it does not exist, the value of `slice_header_extension_length` is inferred to be 0.

[0495] The slice_header_extension_data_byte[i] can have any value. Decoders conforming to this version of the specification should ignore the values ​​of all slice_header_extension_data_byte[i] syntax elements. Its value does not affect the consistency of the decoder with the grade specified in this version of the specification.

[0496] 3.4. Decoding process of inter-frame blocks - fractional sample interpolation process

[0497] In the latest VVC draft text, the decoding process of fractional sample interpolation is as follows:

[0498] The inputs to this process include:

[0499] – Luminance position (xSb, ySb), specifies the top-left sample of the current codec sub-block relative to the top-left luminance sample of the current image.

[0500] – The variable sbWidth specifies the width of the current encoding / decoding sub-block.

[0501] – The variable sbHeight specifies the height of the current encoding / decoding sub-block.

[0502] – Motion vector offset mvOffset

[0503] – Precise motion vector refMvLX

[0504] – The selected reference image sample array refPicLX

[0505] – Half-sample interpolation filter exponent hpelIfIdx,

[0506] – Decoder-side motion vector refinement flag dmvrFlag

[0507] – Bidirectional optical flow flag bdofFlag

[0508] – The variable refPicIsScaled indicates whether the selected reference image needs to be scaled.

[0509] – The variable cIdx specifies the color component index of the current block.

[0510] - A list of horizontal and vertical scaling ratios.

[0511] The output of this process is:

[0512] – The array predSamplesLX, representing the predicted sample values ​​(sbWidth+brdExtSize)x(sbHeight+brdExtSize).

[0513] The derivation of the predicted block boundary extension size brdExtSize is as follows:

[0514] brdExtSize=(bdofFlag||(inter_affine_flag[xSb][ySb]&&!ph_disable_prof_flag))? 2:0 (934)

[0515] The variable refWraparoundEnabledFlag is set to equal to (pps_ref_wraparound_enabled_flag && !refPicIsScaled).

[0516] The variable fRefLeftOffset is set to equal to ((SubWidthC*scaling_win_left_offset)<<10), where scaling_win_left_offset is the scaling_win_left_offset of the reference image.

[0517] The variable fRefTopOffset is set to equal to ((SubWidthC*scaling_win_top_offset)<<10), where scaling_win_top_offset is the scaling_win_top_offset of the reference image.

[0518] The derivation of the array predSamplesLX, representing the predicted sample values ​​(sbWidth + brdExtSize) x (sbHeight + brdExtSize), is as follows:

[0519] – The motion vector mvLX is set to (refMvLX mvOffset).

[0520] – If cIdx equals 0, then the following condition applies:

[0521] – Let (xInt) L yInt L ) is the brightness position given in units of the entire sample point, and (xFrac) L yFrac L The offset is given in units of 1 / 16 sample points. These variables are used only in this clause to specify the fractional sample point positions within the reference sample point array refPicLX.

[0522] – Top-left coordinates of the boundary block filled with reference samples (xSbInt) L ySbInt L ) is set to equal to (xSb+(mvLX[0]>>4), ySb+(mvLX[1]>>4)).

[0523] – For each brightness sample location (x L =0..sbWidth-1+brdExtSize,y L =0..sbHeight-1+brdExtSize), then the corresponding predicted brightness sample value predSamplesLX[x L ][y L The export of ] is as follows

[0524] – Let (refxSb) L ,refySb L ) and (refx L refy L ) is the luminance bit given in units of 1 / 16 samples, pointed to by the motion vector (refMvLX[0], refMvLX[1]). Variable refxSb L refx L ,refySb L and refy L The derivation is as follows:

[0525] refxSb L=(((xSb - (SubWidthC * scaling_win_left_offset)) << 4) + refMvLX[0]) * scalingRatio[0] (935)

[0526] refx L =((Sign(refxSb L ) * ((Abs(refxSb L ) + 128) >> 8) + x L * ((scalingRatio[0] + 8) >> 4)) + fRefLeftOffset + 32) >> 6 (936)

[0528] refySb L =(((ySb - (SubWidthC * scaling_win_top_offset)) << 4) + refMvLX[1]) * scalingRatio[1] (937)

[0530] refy L =((Sign(refySb L ) * ((Abs(refySb L ) + 128) >> 8) + yL * ((scalingRatio[1] + 8) >> 4)) + fRefTopOffset + 32) >> 6 (938)

[0531] – The derivation of variables xInt L , yInt L , xFrac L and yFrac L is as follows:

[0532] xInt L =refx L >> 4 (939)

[0533] yInt L =refy L >> 4 (940)

[0534] xFrac L =refx L & 15 (941)

[0535] yFrac L =refy L & 15 (942)

[0536] –Predicted luminance sample values ​​predSamplesLX[x] L ][y L The derivation of ] is as follows:

[0537] – If bdofFlag equals TRUE or (ph_disable_prof_flag equals FALSE, and inter_affine_flag[xSb][ySb] equals TRUE), and one or more of the following conditions are TRUE, then the predicted luminance sample value predSamplesLX[x] is derived by calling the luminance integer sample acquisition procedure specified in Clause 8.5.6.3.3. L ][y L ], where (xInt L +(xFrac L >>3)-1、yInt L +(yFrac L >>3)-1, refPicLX and refWraparoundEnabledFlag are used as inputs.

[0538] -x L It equals 0.

[0539] -x L It equals sbWidth+1.

[0540] –y L It equals 0.

[0541] –y L It equals sbHeight + 1.

[0542] – Otherwise, the predicted luminance sample values ​​predSamplesLX[x] are obtained by invoking the luminance sample 8-tap interpolation filtering procedure as specified in Clause 8.5.6.3.2. L ][y L ], where (xIntL-(brdExtSize>0?1:0), yIntL-(brdExtSize>0?1:0)), (xFracL, yFracL), (xSbInt L ,ySbInt L ), refPicLX, hpelIfIdx, sbWidth, sbHeight, dmvrFlag, refWraparoundEnabledFlag, scalingRatio[0], scalingRatio[1] and (xSb, ySb) are used as inputs.

[0543] Otherwise (cIdx is not equal to 0), the following applies:

[0544] – Let (xIntC, yIntC) be the chromaticity position given in units of the full sample, and (xFracC, yFracC) be the offset given in units of 1 / 32 sample points. These variables are used only in this clause to specify the general fractional sample point positions within the reference sample point array refPicLX.

[0545] – The top-left coordinates (xSbIntC, ySbIntC) of the boundary block filled by the reference sample points are set to equal to ((xSb / SubWidthC)+(mvLX[0]>>5), (ySb / SubHeightC)+(mvLX[1]>>5)).

[0546] – For each chromaticity sample location (xC = 0..sbWidth-1, yC = 0..sbHeight-1) within the predicted chromaticity sample array predSamplesLX, the derivation of the corresponding predicted chromaticity sample value predSamplesLX[xC][yC] is as follows:

[0547] – Let (refxSb) C ,refySb C ) and (refx C refy C ) is the chromaticity position pointed to by the motion vector (refMvLX[0], refMvLX[1]) given in units of 1 / 32 samples. Variable refxSb C ,refySb C refx C and refy C The derivation is as follows:

[0548] addX=sps_chroma_horizontal_collocated_flag? 0:8*(scalingRatio[0]-(1<<14)) (943)

[0549] addY=sps_chroma_vertical_collocated_flag? 0:8*(scalingRatio[1]-(1<<14)) (944)

[0550] refxSb C =(((xSb-(SubWidthC*scaling_win_left_offset)) / SubWidthC<<5)+refMvLX[0])*scalingRatio[0]+addX (945)

[0551] refx C= ((Sign(refxSb C )* ((Abs(refxSb C ) + 256) >> 9) + xC * ((scalingRatio[0] + 8) >> 4)) + fRefLeftOffset / SubWidthC + 16) >> 5 (946)

[0552] refySb C

[0553] = (((ySb - (SubWidthC * scaling_win_top_offset)) / SubHeightC << 5) + refMvLX[1]) * scalingRatio[1] + addY (947)

[0554] – refy C = ((Sign(refySb C ) * ((Abs(refySb C ) + 256) >> 9) + yC * ((scalingRatio[1] + 8) >> 4)) + fRefTopOffset / SubHeightC + 16) >> 5 (948)

[0555] – variable xInt C 、yIntC、xFrac C and yFrac C are derived as follows:

[0556] xInt C = refx C >> 5 (949)

[0557] yInt C = refy C >> 5 (950)

[0558] xFrac<( C = refx C & 31 (951)

[0559] yFrac C = refy C & 31 (952)

[0560] It should be noted that there might be a small error in the original text where "<( C " is likely a typo and should probably be " C ". This has been corrected in the translation for better readability.– The predicted sample values ​​predSamplesLX[xC][yC] are obtained by calling the procedure specified in Clause 8.5.6.3.4, where (xIntC,yIntC), (xFracC,yFracC), (xSbIntC,ySbIntC), sbWidth, sbHeight, refPicLX, dmvrFlag, refWraparoundEnabledFlag, scalingRatio[0], and scalingRatio[1] are used as inputs.

[0561] Note—This procedure differs from the procedure specified in Clause 8.4.5.2.13, and uses sps_chroma_vertical_collocated_flag and sps_chroma_horizontal_collocated_flag.

[0562] 4. Technical problems solved by the technical solutions and embodiments

[0563] Existing deblocking, scaling, and PROF designs have the following problems:

[0564] 1) Currently, there are some issues with the design logic of deblocking (DB) control in PPS, PH, and SH syntax elements.

[0565] a. First, based on the current semantics of the PPS syntax element `pps_deblocking_filter_disabled_flag`, the SH syntax element `slice_deblocking_filter_disabled_flag` will be checked. The PPS syntax element `pps_deblocking_filter_disabled_flag` specifies whether a deblocking filter should be applied to the slices of the reference PPS. However, in addition to `slice_deblocking_filter_disabled_flag`, the PH syntax element `ph_deblocking_filter_disabled_flag` should also be checked along with `pps_deblocking_filter_disabled_flag`. Therefore, the current semantics of `pps_deblocking_filter_disabled_flag` are incorrect.

[0566] b. Secondly, according to the current draft text, when the SH syntax element slice_deblocking_filter_override_flag does not exist, it is inferred to be equal to ph_deblocking_filter_override_flag. However, apart from implicit or explicit signaling notification in PPS, deblocking parameters can only be signaled in PH or SH according to dbf_info_in_ph_flag, not both. Therefore, when dbf_info_in_ph_flag is true, the intention is to allow signaling notification of overriding deblocking filter parameters in PH. In this case, if the PH overriding flag is true and the SH overriding flag is not signaled, but is inferred to be equal to the PH overriding flag, then the additional deblocking filter parameters will still be signaled in SH, which conflicts with the intention.

[0567] c. Third, according to the current draft text, if the PPS syntax element `deblocking_filter_override_enabled_flag` is equal to 1, and `pps_deblocking_filter_disabled_flag` is also equal to 1, then `ph_deblocking_filter_disabled_flag` or `slice_deblocking_filter_disabled_flag` can still be explicitly signaled to be equal to 1. However, this situation means that deblocking is disabled in PPS, and it will be overridden, but the overriding process does not change anything (e.g., deblocking remains disabled in PH / SH), but instead wastes bits used for signaling notification.

[0568] d. Fourth, the current deblocking design logic allows deblocking to be enabled in PH / SH, even if it is disabled in PPS. This design logic differs greatly from that of most other codec tools, such as ALF, SAO, LMCS, TMVP, WP, etc.

[0569] The PPS DB disable flag (i.e., pps_deblocking_filter_disabled_flag) is only signaled when deblocking_filter_control_present_flag equals 1; if the flag is not present, it is inferred to be equal to 0. In other words, the goal is to enable DB by default. Both syntax elements (i.e., the PPS DB disable flag and deblocking_filter_control_present_flag) are somewhat redundant. A better design is necessary.

[0570] 2) According to the latest VVC draft text, the size of the prediction block generated for PROF depends on whether it is an affine AMVP or an affine MERGE block. Assuming sbWidth and sbHeight are the width and height of a sub-block of an affine codec block, in the current text, according to the condition "inter_affine_flag[xSb][ySb]&&!ph_disable_prof_flag", when PROF is applied to an affine AMVP block, prediction blocks with extended samples (such as (sbWidth+2)x(sbHeight+2)) are used for PROF; however, when PROF is applied to an affine MERGE block, prediction blocks with sbWidth x sbHeight are used for PROF. This design leads to different processing mechanisms between PROF with affine AMVP and PROF with affine MERGE.

[0571] a. Furthermore, an 8-tap interpolation filter is used to generate internal prediction samples within sub-blocks of the PROF, and integer samples other than those from the 8-tap filter are used to generate extended prediction samples outside sub-blocks of the PROF. However, according to the current text, no extended samples are used for the PROF with affine MERGE, which leads to a difference between the PROF with affine AMVP and the PROF with affine MERGE.

[0572] 3) Currently, image-level or stripe-level luminance qp increments are always signaled in either PH or SH, not both. Stripe-level chroma qp offsets are optionally signaled in SH, and there is no PH signaling for image-level chroma qp offsets. This design may be inconsistent / inefficient / inflexible.

[0573] 4) In the latest VVC draft text, the definition of the allowed value ranges for PH syntax elements (such as ph_cu_qp_delta_subdiv_intra_slice, ph_cu_qp_delta_subdiv_inter_slice, ph_cu_chroma_qp_offset_subdiv_intra_slice, and ph_cu_chroma_qp_offset_subdiv_inter_slice) related to incremental QP signaling notifications may not be precise.

[0574] 5. List of examples of solutions and implementation methods

[0575] To address the aforementioned issues and other unmentioned problems, the following outlines the proposed methods. These items should be considered as examples for interpreting the overall concept, and not interpreted in a narrow sense. Furthermore, these items can be applied individually or in combination in any way.

[0576] In the following discussion, DBF parameters may include DBF on / off control parameters and DBF filtering parameters (e.g., an indication of the β(beta) / Tc offset, such as pps_beta_offset_div2).

[0577] In the following discussion, SH can be associated with PH, meaning SH is associated with a band that is in an image associated with PH. SH can be associated with PPS, meaning SH is associated with a band that is in an image associated with PPS. PH can be associated with PPS, meaning PH is associated with an image that is associated with PPS.

[0578] In the following discussion, SPS may be associated with PPS, that is, PPS may refer to SPS.

[0579] 1. Regarding the design of deblocking control in PPS, PH, and SH for solving the first problem, one or more of the following methods are disclosed, for example, in the first set of embodiments:

[0580] a. In one example, whether the operation of the deblocking filter is applied to the stripe of the reference PPS may depend on the deblocking on / off flag of the associated PH (e.g., ph_deblocking_filter_disabled_flag).

[0581] i. For example, whether the operation of the deblocking filter is applied to the slice of the reference PPS may depend on whether deblocking is disabled in the PPS (e.g., pps_deblocking_filter_disabled_flag equals 1), whether deblocking is disabled at the image level (e.g., ph_deblocking_filter_disabled_flag equals 1), and whether deblocking is disabled at the slice level (e.g., slice_deblocking_filter_disabled_flag equals 1).

[0582] ii. Alternatively, whether the operation of the deblocking filter is applied to the slice of the reference PPS may depend on whether deblocking is disabled in the PPS (e.g., pps_deblocking_filter_disabled_flag equals 1) and whether deblocking override is disabled at both the image and slice levels (e.g., deblocking_filter_override_enabled_flag equals 0).

[0583] iii. Alternatively, whether the operation of the deblocking filter is applied to the stripe of the reference PPS may depend solely on whether deblocking is disabled in the PPS (e.g., pps_deblocking_filter_disabled_flag equals 1).

[0584] b. In addition, when slice_deblocking_filter_override_flag does not exist, the value of slice_deblocking_filter_override_flag can be independent of ph_deblocking_filter_override_flag (it can be inferred to be a specific value, such as 0).

[0585] c. Additionally, optionally, whether the PH syntax element ph_deblocking_filter_disabled_flag and / or the SH syntax element slice_deblocking_filter_disabled_flag are explicitly signaled or implicitly inferred may depend on the value of the PPS deblocking on / off flag, such as pps_deblocking_filter_disabled_flag.

[0586] d. It is proposed that if DBF is disabled at the first level (e.g., in PPS), it should not be enabled at a lower level (e.g., PH / SH).

[0587] i. For example, the presence of image / strip level DBF on / off control parameters in PH / SH can directly depend on the value of the DBF on / off flag (e.g., pps_deblocking_filter_disabled_flag) in signaling notification in PPS, rather than the value of the DBF overlay flag in signaling notification in PH / SH.

[0588] 1) For example, when the PPS DBF on / off control parameter specifies that deblocking is disabled for the stripe of the reference PPS (pps_deblocking_filter_disabled_flag equals 1), then the PH / SH DBF on / off control parameter can be notified without signaling.

[0589] ii. Additionally, the presence of DBF on / off control parameters at PPS / PH / SH can be directly adjusted based on the DBF global control flag (e.g., deblocking_filter_control_present_flag in PPS), which specifies the presence of DBF on / off control parameters and DBF filter parameters in PPS, PH, and SH.

[0590] 1) For example, when the DBF global control flag specifies that neither DBF on / off control parameters nor DBF filter parameters are signaled (deblocking_filter_control_present_flag equals 0), then PPS / PH / SH DBF on / off control parameters can be not signaled.

[0591] iii. Additionally, when the PPS deblocking on / off flag is not present, it can be inferred that it is equal to a specific value, such as 0 or 1.

[0592] iv. Additionally, when the PH deblocking on / off flag is not present, it can be inferred that it is equal to the value of the PPS deblocking on / off flag.

[0593] v. Additionally, when the SH deblocking on / off flag is not present, it can be inferred that it is equal to the value of the PPS / PH deblocking on / off flag.

[0594] e. It is proposed that if DBF is enabled at the first level (e.g., in PH), it can be disabled at a lower level (e.g., SH).

[0595] i. For example, for multiple stripes in an image, some stripes are allowed to use a deblocking filter, while others are not.

[0596] ii. For example, the signaling notification of the DBF on / off control flag in SH may depend on the timing of the PHDBF on / off control flag.

[0597] 1) For example, when DBF is enabled for the current image, the DBF on / off control flag at the strip level can be further signaled to specify whether the current strip uses a deblocking filter.

[0598] The signaling notification of the f.PPS syntax element “dbf_info_in_ph_flag” can be independent of other syntax elements, such as deblocking_filter_override_enabled_flag. The syntax element “dbf_info_in_ph_flag” specifies whether DBF on / off control parameters and / or DBF filter parameters exist in PH or SH.

[0599] i. Alternatively, signaling notifications for the image / strip level DBF on / off flags in PH / SH can be directly adjusted based on dbf_info_in_ph_flag and / or pps_deblocking_filter_enabled_flag instead of the PH / SH DBF overriding flags.

[0600] g. It is proposed that the DBF coverage flag in PPS / PH / SH is only used to cover DBF filter parameters, not DBF on / off control parameters.

[0601] i. For example, first signaling the DBF on / off control flag, then signaling the DBF overlay flag, provided that the DBF on / off control flag is based on the same level (e.g., PPS / PH / SH).

[0602] 1) For example, the on / off control parameters of the picture / strip level DBF can be signaled in PH / SH, regardless of whether the PH / SH DBF coverage flag is true.

[0603] 2) For example, image / strip level DBF on / off control parameters can be signaled in PH / SH, regardless of whether the PPS DBF overlay flag is true.

[0604] 3) For example, the DBF coverage flag is conditionally signaled based on the DBF on / off control flag at the same level (e.g., PPS / PH / SH).

[0605] a. For example, signaling notification of the PPS deblocking override enabled flag (e.g., deblocking_filter_override_enabled_flag) may depend on whether deblocking is enabled in the PPS (e.g., pps_deblocking_filter_disabled_flag in the PPS is equal to 0).

[0606] i. For example, when deblocking is disabled in PPS, the PPS syntax element deblocking_filter_override_enabled_flag is not signaled.

[0607] b. For example, signaling notification of the PH deblocking override flag (e.g., ph_deblocking_filter_override_flag) may depend on whether deblocking is enabled in the PH (e.g., ph_deblocking_filter_disabled_flag equals 0).

[0608] i. For example, when deblocking is disabled in PH, the PH syntax element ph_deblocking_filter_override_flag is not signaled.

[0609] c. For example, signaling notification of SH deblocking override flags (e.g., slice_deblocking_filter_override_flag) may depend on whether deblocking is enabled in SH (e.g., slice_deblocking_filter_disabled_flag equals 0).

[0610] i. For example, when deblocking is disabled in SH, the SH syntax element slice_deblocking_filter_override_flag is not signaled.

[0611] d. Additionally, when the PPS / PH / SH deblocking overwrite flag is not present, it can be inferred that it is equal to a specific value (e.g., 0).

[0612] 4) For example, the signaling notification of DBF filter parameters can depend directly on the DBF coverage flag, rather than the DBF on / off control flag.

[0613] a. For example, the presence of DBF filter parameters in PH (e.g., ph_beta_offset_div2, ph_tc_offset_div2, ph_cb_beta_offset_div2, ph_cb_tc_offset_div2, ph_cr_beta_offset_div2, ph_cr_tc_offset_div2) can be directly adjusted based on the DBF override flag in PH (e.g., ph_deblocking_filter_override_flag) rather than the DBF on / off flag in PH (e.g., ph_deblocking_filter).

[0614] b. For example, the DBF filter parameters in SH (e.g., slice_beta_offset_div2, slice_tc_offset_div2, slice_cb_beta_offset_div2, slice_cb_tc_offset_div2, slice_cr_beta_offset_div2, slice_cr_tc_offset_div2) can be directly adjusted based on the DBF override flag in SH (e.g., slice_deblocking_filter_override_flag) instead of the DBF on / off flag in SH (e.g., slice_deblocking_filter).

[0615] h. proposed that DBF on / off control in PPS / PH / SH can rely on the DBF "enabled" flag instead of the DBF "disabled" flag.

[0616] i. For example, a DBF enable flag (e.g., named pps_deblocking_filter_enabled_flag) can be signaled to the PPS to specify whether deblocking is enabled for stripes of the reference PPS.

[0617] ii. For example, the PPS DBF enable flag can be used for signaling notification independently of other syntax elements such as DBF global control flags (e.g., deblocking_filter_control_present_flag in PPS).

[0618] iii. For example, if DBF is disabled at a higher level (e.g., PPS or PH), then the signaling notification for the DBF enable flag at a lower level (e.g., PH and / or SH) is not present and is inferred to be equal to the value of the on / off control flag at the higher level (e.g., PPS / PH).

[0619] iv. For example, DBF global control flags (e.g., deblocking_filter_control_present_flag in PPS) can be used only to control the presence of the DBF overlay flag and the DBF filter parameters at PPS / PH / SH.

[0620] 1) For example, DBF global control flags (e.g., deblocking_filter_control_present_flag in PPS) are not used to control the presence of DBF on / off control parameters at PPS / PH / SH.

[0621] 2) For example, the DBF global control flag is only signaled when DBF is enabled in PPS (e.g., pps_deblocking_filter_enabled_flag equals 1).

[0622] a. For example, when DBF is disabled in PPS (e.g., pps_deblocking_filter_enabled_flag equals 0), no signaling is sent to the DBF global control flag.

[0623] b. In addition, when deblocking is disabled in PPS, the deblocking_filter_control_present_flag is inferred to be equal to 0.

[0624] 3) For example, signaling notifications for DBF override enable / disable flags in PPS (e.g., deblocking_filter_override_enabled_falg in PPS) can be directly adjusted based on DBF global control flags in PPS instead of DBF on / off flags.

[0625] 4) For example, signaling notifications for PPS DBF parameters (such as increments and tc values) can be directly adjusted based on the DBF global control flags in the PPS instead of the DBF on / off flags.

[0626] i. It proposes allowing coverage of DBF on / off control parameters or DBF filter parameters, but not both.

[0627] i. In one example, an overlay mechanism can be allowed at PPS / PH / SH.

[0628] ii. In one example, if only the DBF on / off control parameters can be overridden at different levels (e.g., PPS / PH / SH), then the following may be further applicable:

[0629] 1) If DBF is enabled for smaller video units, DBF filter parameters can be notified only at the first level (e.g., in PPS) and all smaller video units (e.g., pictures / strips) inherit the parameters associated with the first level.

[0630] iii. In one example, if only the DBF filter parameters can be covered at different levels (e.g., PPS / PH / SH), then the following may be further applicable:

[0631] 1) If DBF is enabled for smaller video units, the DBF on / off control parameters can be signaled only at the first level (e.g., in PPS), and all smaller video units (e.g., pictures / strips) inherit the parameters associated with the first level.

[0632] j. Proposes that when DBF is disabled at a higher level (e.g., in PPS), the DBF on / off control parameters should not be overridden in smaller video units (e.g., in PH / SH).

[0633] i. Optionally, signaling notifications for DBF on / off control parameters at a smaller video unit level (e.g., in PH / SH) can be checked under the condition that DBF on / off control parameters at a higher level (e.g., in PPS) are turned on.

[0634] 1) Optionally, in addition, when DBF is not present at a smaller video unit level, it is inferred that it is disabled or enabled at a higher video unit level, or is equal to an on / off state.

[0635] k. In PPS, “deblocking_filter_control_present_flag” can be removed, and the first syntax element indicating whether DBF is enabled or disabled can be directly signaled instead of being controlled by “deblocking_filter_control_present_flag”.

[0636] i. Optionally, further signaling notification may be provided, based on the first syntax element corresponding to enabling DBF, to inform whether a second syntax element is allowed to override the DBF filter parameters.

[0637] 1) Alternatively, DBF filter parameters can be notified by signaling of the second syntax element that allows coverage.

[0638] l. In PPS, "deblocking_filter_control_present_flag" can be removed, and the first syntax element indicating whether to allow overriding DBF parameters can be directly signaled instead of being controlled by "deblocking_filter_control_present_flag".

[0639] i. Alternatively, the second syntax element that informs whether DBF is enabled or disabled can be further signaled based on the first syntax element that is allowed to be overridden.

[0640] 1) Optionally, DBF filter parameters can also be notified by a second syntax element signaling that DBF is enabled.

[0641] m. Syntax elements indicating whether DBF on / off control flags and / or DBF parameters are signaled in PH or SH (e.g., dbf_info_in_ph_flag) can be signaled in PH instead of PPS.

[0642] n. In one example, DBF on / off control flags and / or DBF parameters can be signaled in PH and SH.

[0643] i. For example, the DBF on / off control flags and / or DBF parameters in the signaling notification in SH can override the DBF on / off control flags and / or DBF parameters in the signaling notification in PH.

[0644] o. It proposes that DBF on / off control flags and / or DBF parameters can be signaled in SPS.

[0645] i. The DBF on / off control flag in the signaling notification of i.SPS can be overridden by the DBF on / off control flag in the signaling notification of lower-level video units (such as PPS, PH or SH).

[0646] ii. The DBF parameters of the signaling notification in SPS can be overridden by the DBF parameters of the signaling notification in lower-level video units (such as PPS, PH, or SH).

[0647] p. Syntax with non-binary values ​​(e.g., indicators other than flags) can be signaled at the video unit level (e.g., PPS / SPS) to specify the deblocking mode, for example, as in the first set of embodiments (such as the embodiments in section 6.1.4 of this document). In one example, an N-bit mode indicator can be signaled in the PPS to specify the deblocking filter mode.

[0648] i. For example, N = 2.

[0649] ii. For example, a 2-bit mode indicator (e.g., named deblocking_filter_mode_idc) is added to the PPS and has the following semantics:

[0650] `deblocking_filter_mode_idc` equal to 0 specifies that the deblocking filter should not be applied to any slices of the reference PPS. `deblocking_filter_mode_idc` equal to 1 specifies that the deblocking filter is applied to all slices of the reference PPS using the deblocking parameter offset of 0 values ​​for β and tC. `deblocking_filter_mode_idc` equal to 2 specifies that the deblocking filter is applied to all slices of the reference PPS using the deblocking parameter offset of β and tC explicitly signaled in the PPS. `deblocking_filter_mode_idc` equal to 3 specifies that whether the deblocking filter is applied to slices of the reference PPS is controlled by the slice's PH or parameters present in the slice header.

[0651] iii. In addition, the signaling notification of DBF filter parameters in PPS depends on the value of the mode indicator.

[0652] a. For example, if the mode indicator meets a specific condition (e.g., greater than a specific value X, such as X = 1), the DBF filter parameters are signaled in the PPS. Otherwise, the PPS DBF filter parameters are inferred to be 0.

[0653] iv. In addition, the signaling notification specifying whether the DBF on / off control parameters and / or DBF filter parameters exist in the PPS syntax element "dbf_info_in_ph_flag" in PH or SH may depend on the value of the mode indicator.

[0654] a. For example, if the pattern indicator meets a specific condition (e.g., equals a specific value Y, such as Y=3), the signaling notifies the PPS syntax element "dbf_info_in_ph_flag".

[0655] i. In addition, if the PPS syntax element “dbf_info_in_ph_flag” is not signaled, it is inferred that it is equal to a specific value (such as 0 or 1).

[0656] v. Furthermore, the signaling notification of DBF on / off control parameters and / or DBF filter parameters in PH or SH may depend on the value of the mode indicator.

[0657] a. For example, if the pattern indicator meets a specific condition (e.g., equal to a specific value Y, such as Y=3), the picture level DBF on / off control flag can be signaled in the PH.

[0658] b. For example, if the pattern indicator meets a specific condition (e.g., equals a specific value Y, such as Y=3), the strip level DBF on / off control flag can be signaled in the SH.

[0659] q.DBF can be enabled at the pic / slice level, and the DBF parameter uses a value of 0 with a beta / tc offset.

[0660] i. In one example, one or more syntax elements (e.g., named explicit_default_deblocking_params_flag) can be signaled in the PPS to specify whether the default DBF parameter has a β / tc offset with a value of 0 or an explicitly signaled β / tc offset, and only in the latter case is the β / tc offset explicitly signaled. The DBF parameter determined by the PPS and the default DBF parameter may or may not be overridden at the picture level or the stripe level.

[0661] ii. In one example, one or more syntax elements (e.g., named explicit_default_deblocking_params_flag) can be signaled at the video unit level (e.g., SPS / PPS / PH / SH) to specify whether to use a 0-value β / tc offset or to explicitly signal the β / tc offset, in the latter case, to explicitly signal the β / tc offset.

[0662] 2. Regarding the processing mechanism for PROFs with affine AMVP and PROFs with affine MERGE used to solve the second problem, for example, as in the second set of embodiments, one or more of the following methods are disclosed:

[0663] a. For blocks encoded and decoded by affine MERGE, PROF can still be applied, and the predicted block size corresponding to M*N sub-blocks (or blocks) can be greater than M*N, that is, represented by (M+M0)*(N+N0), where M0 and N0 are not both equal to 0.

[0664] i. In one example, M0 and N0 are set to 2.

[0665] b. Whether to use extended samples to generate PROF prediction blocks (sub-blocks) and / or how many extended samples to generate for PROF prediction blocks (sub-blocks) may depend on prediction refinement utilization flags, such as cbProfFlagLX, where X is 0 or 1.

[0666] i. Specific values ​​of the predicted block boundary extension size (e.g., the width and / or height and / or the number of sample points of the extension) can be used, whether it is a PROF subblock with affine AMVP or a PROF subblock with affine MERGE.

[0667] a) For example, for an M×N subblock applying PROF, where M is the subblock width and N is the subblock height, X (e.g., X=2) expansion samples on the width and Y (e.g., Y=2) expansion samples on the height can be used to construct (M+X)x(N+Y) prediction samples for the PROF subblock, whether it is a PROF subblock with affine AMVP or a PROF subblock with affine MERGE.

[0668] ii. Integer samples are used to generate extended samples for PROF prediction, whether it is a PROF sub-block with affine AMVP or a PROF sub-block with affine MERGE.

[0669] 3. Regarding the PH and SH qp incremental / offset signaling notifications used to address the third issue, one or more of the following methods are disclosed:

[0670] a. In one example, compared to PH / SH (e.g., SPS / PPS), the first syntax element can signal at a higher level to indicate whether luminance / chrominance incremental QP signaling notification is enabled.

[0671] i. In one example, the presence of luminance qp increments in PH and / or SH may depend on an SPS / PPS luminance qp increment presence flag (e.g., pps_pic_slice_luma_qp_delta_present_flag), for example, as in the third embodiment.

[0672] a) For example, if there is a flag indicating that the brightness qp increment of SPS / PPS should not be signaled to either PH or SH, then it is required that the brightness qp increment should not be signaled to either PH or SH.

[0673] a. Optionally, if the SPS / PPS brightness qp increment presence flag specifies that the PH / SH brightness qp increment does not exist, then it is required that the brightness qp increment not be signaled in the PH / SH.

[0674] b. In addition, if the PH brightness qp increment is not present, it can be inferred to be a specific value (e.g., 0).

[0675] c. In addition, if the SH brightness qp increment does not exist, it can be inferred to be a specific value (e.g., 0 or equal to the PH brightness qp increment).

[0676] b) In addition, the presence of a PPS switch flag (e.g., qp_delta_info_in_ph_flag) that specifies whether the brightness qp increment is signaled in PH or SH may depend on the presence of the aforementioned SPS / PPS brightness qp increment flag.

[0677] a. For example, if the SPS / PPS brightness qp increment flag specifies that neither the PH brightness qp increment nor the SH brightness qp increment should be signaled, then the PPS switch flag should not be signaled.

[0678] i. Furthermore, if the PPS switch flag is not present, it can be inferred that it is equal to a specific value (e.g., 0).

[0679] b. In one example, the chromaticity (e.g., Cb, Cr, combined CbCr) qp offset can be notified at a higher level of signaling compared to SH (e.g., in PH, for example, as in the third embodiment).

[0680] i. For example, whether signaling notification of chroma qp offset in PH or SH can depend on PPS switch flags (e.g., qp_offset_info_in_ph_flag).

[0681] a) For example, if the PPS switch flag specifies that the chroma qp offset is signaled in PH, then the chroma qp offset is not signaled in SH.

[0682] a. Alternatively, if the PPS switch flag specifies that the chroma qp offset is not signaled in PH, then the chroma qp offset can be signaled in SH.

[0683] b. In addition, if the PH chromaticity qp offset is not present, it can be inferred to be a specific value (e.g., 0).

[0684] c. In addition, if the SH chromaticity qp offset does not exist, it can be inferred to be a specific value (e.g., 0 or equal to the PH chromaticity qp offset).

[0685] b) In one example, this flag is the same as the flag that controls whether the brightness increment qp is signaled in PH or SH.

[0686] ii. Alternatively, the presence of chroma qp offset in PH and / or SH may depend on the SPS / PPS chroma qp offset presence flag (e.g., pps_pic_slice_chroma_qp_offset_present_flag).

[0687] a) For example, if the SPS / PPS chroma qp offset has a flag specifying that neither the PH chroma qp offset nor the SH chroma qp offset should be signaled, then it is required that the chroma qp offset not be signaled in the PH and not in the SH.

[0688] b) Additionally, the presence of a PPS switch flag (e.g., qp_offset_info_in_ph_flag) that specifies whether the chroma qp offset is signaled in PH or SH may depend on the aforementioned SPS / PPS chroma qp offset presence flag.

[0689] a. If the SPS / PPS chroma qp offset flag specifies that neither the PH chroma qp offset nor the SH chroma qp offset should be signaled, then the PPS switch flag should not be signaled.

[0690] i. Furthermore, if the PPS switch flag is not present, it can be inferred that it is equal to a specific value (e.g., 0).

[0691] iii. Signaling notifications for qp_delta and chroma qp offset can always be in the same header.

[0692] a) For example, when qp_delta is signaled in PH, the chroma qp offset should not be signaled in SH.

[0693] b) For example, when qp_delta is signaled in SH, the chroma qp offset should not be signaled in PH.

[0694] 4. Regarding the scope of the PH syntax elements ph_cu_qp_delta_subdiv_intra_slice, ph_cu_qp_delta_subdiv_inter_slice, ph_cu_chroma_qp_subdiv_intra_slice, and ph_cu_chroma_qp_offset_subdiv_inter_slice used to solve the second problem, for example, as disclosed in the fourth embodiment, one or more of the following methods are provided:

[0695] a. The range of the maximum cbSubdiv value of the codec unit in the intra-slice (e.g., ph_cu_qp_delta_abs, cu_qp_delta_sign_flag) transmitting cu_qp_delta_abs and cu_qp_delta_sign_flag can be independent of ph_max_mtt_hierarchy_depth_intra_slice_luma, for example, it can be in the range of 0 to 2*(CtbLog2SizeY - MinQtLog2SizeIntraY) + 2*(CtbLog2SizeY - MinCbLog2SizeY) (inclusive).

[0696] i. Optionally, it can be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_intra_slice_luma,CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0697] b. The range of the maximum cbSubdiv value of the codec unit in the intra-slice (e.g., ph_cu_chroma_qp_offset_flag) transmitting cu_chroma_qp_offset_subdiv_intra_slice may not depend on ph_max_mtt_hierarchy_depth_intra_slice_luma, for example, it may be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0698] i. Optionally, it can be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_intra_slice_luma,CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0699] c. The range of the maximum cbSubdiv value of the codec unit for transmitting cu_qp_delta_abs and cu_qp_delta_sign_flag (e.g., ph_cu_qp_delta_subdiv_inter_slice) may be independent of ph_max_mtt_hierarchy_depth_inter_slice, for example, it may be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0700] i. Optionally, it can be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_inter_slice,CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0701] d. The range of the maximum cbSubdiv value of the codec unit in the inter-frame slice (e.g., ph_cu_chroma_qp_offset_flag) transmitting cu_chroma_qp_offset_subdiv_inter_slice) may be independent of ph_max_mtt_hierarchy_depth_inter_slice, for example, it may be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0702] i. Optionally, it can be in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_inter_slice,CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0703] 6. Example

[0704] The following are some example embodiments of aspects of the invention outlined in Section 5 above, which can be applied to the VVC specification. The modified text is based on the latest VVC text in JVET-Q2001-vD. Most of the relevant parts that have been added or modified are highlighted in bold and italics, and some deleted parts are highlighted with double brackets (e.g., [[]]), with the deleted text enclosed in double brackets.

[0705] 6.1. First set of embodiments

[0706] This is a set of embodiments of Project 1 (from 1.a to 1.o) outlined in Section 5 above.

[0707] 6.1.1. Example of item 1.a

[0708] In one example, the semantics of pps_deblocking_filter_disabled_flag change as follows:

[0709] The value of 1 indicates that the operation of the deblocking filter should not be applied to the reference. slice_deblocking_filter_disabled_flag [[does not exist]] The PPS stripe. A flag of 0 for pps_deblocking_filter_disabled_flag specifies that the deblocking filter operation applies to the reference. slice_deblocking_filter_disabled_flag[[yes]] A stripe of PPS that does not exist. When it does not exist, the value of pps_deblocking_filter_disabled_flag is inferred to be equal to 0.

[0710] 6.1.2. Example of item 1.b

[0711] In one example, the semantics of slice_deblocking_filter_override_flag change as follows:

[0712] A value of 1 indicates that the deblocking parameter exists in the slice header. A value of 0 indicates that the deblocking parameter does not exist in the slice header. When it does not exist, the value of slice_deblocking_filter_override_flag is inferred to be equal to [[ph_deblocking_filter_override_flag]].

[0713] 6.1.3. Example of item 1.c

[0714] In one example, the syntax structure picture_header_structure() is modified as follows:

[0715]

[0716]

[0717] A value of 1 indicates that the deblocking filter operation should not be applied to stripes associated with pH. A value of 0 indicates that the deblocking filter operation should be applied to stripes associated with pH. When ph_deblocking_filter_disabled_flag does not exist At that time, ph_deblocking_filter_disabled_flag is inferred to be equal to pps_deblocking_filter_disabled_flag.

[0718] Furthermore, the syntax structure slice_header() has been changed as follows:

[0719]

[0720]

[0721] A value of 1 indicates that the deblocking parameter exists in the slice header. A value of 0 indicates that the deblocking parameter does not exist in the slice header. When it does not exist, the value of slice_deblocking_filter_override_flag is inferred to be equal to [[ph_deblocking_filter_override_flag]].

[0722] A value of 1 indicates that the deblocking filter operation should not be applied to the current slice. A value of 0 indicates that the deblocking filter operation should be applied to the current slice. When slice_deblocking_filter_disabled_flag does not exist At that time, slice_deblocking_filter_disabled_flag is inferred to be equal to ph_deblocking_filter_disabled_flag.

[0723] 6.1.4. Example of item 1.p

[0724] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0725]

[0726] ...

[0728]

[0729] [[ A value of 1 indicates the presence of the deblocking filter control syntax element in PPS. A value of 0 indicates the absence of the deblocking filter control syntax element in PPS.

[0730] [[ A value of 1 indicates that `ph_deblocking_filter_override_flag` exists in the PH of the reference PPS, or that `slice_deblocking_filter_override_flag` exists in the slice header of the reference PPS. A value of 0 indicates that `ph_deblocking_filter_override_flag` does not exist in the PH of the reference PPS, or that `slice_deblocking_filter_override_flag` does not exist in the slice header of the reference PPS. When it does not exist, the value of `deblocking_filter_override_enabled_flag` is inferred to be 0.

[0731] [[ A value of 1 indicates that the deblocking filter operation should not be applied to slices of PPS that reference the absence of `slice_deblocking_filter_disabled_flag`. A value of 0 indicates that the deblocking filter operation should be applied to slices of PPS that reference the absence of `slice_deblocking_filter_disabled_flag`. When it does not exist, the value of `pps_deblocking_filter_disabled_flag` is inferred to be 0.

[0732] A value of 1 indicates that the deblocking filter information exists within the PH syntax structure, but not in the strip header of a PPS that does not contain a PH syntax structure. A value of 0 indicates that the deblocking filter information does not exist within the PH syntax structure, but may exist in the strip header of a PPS that does not contain a PH syntax structure. [[When it does not exist, the value of dbf_info_in_ph_flag is inferred to be 0.]] ...

[0734] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0735] ...

[0737]

[0738] An equality of 1 indicates that the deblocking parameter exists in PH, ph_deblocking_[[filter]]. A value of 0 for `_override_flag` indicates that the deblocking parameter does not exist in the ph_deblocking_filter_override_flag. [[When it does not exist, the value of `ph_deblocking_filter_override_flag` is inferred to be 0.]]

[0739] [[ A value of 1 indicates that the deblocking filter operation should not be applied to stripes associated with pH. A value of 0 indicates that the deblocking filter operation should be applied to stripes associated with pH. When ph_deblocking_filter_disabled_flag does not exist, it is inferred to be equal to pps_deblocking_filter_disabled_flag. ...

[0741] Furthermore, the syntax structure slice_header() has been changed as follows:

[0742]

[0743] ...

[0745]

[0746] An equality of 1 indicates that the deblocking parameter exists in the slice header. `slice_deblocking_[[filter]]` A value of 0 for `_override_flag` indicates that the deblocking parameter does not exist in the slice header. [[When it does not exist, the value of `slice_deblocking_filter_override_flag` is inferred to be equal to `ph_deblocking_filter_override_flag`.]]

[0747] [[ A value of 1 indicates that the deblocking filter operation should not be applied to the current slice. A value of 0 indicates that the deblocking filter operation should be applied to the current slice. When slice_deblocking_filter_disabled_flag does not exist, it is inferred to be equal to ph_deblocking_filter_disabled_flag. ...

[0749] Furthermore, the decoding process of the deblocking filtering process is changed as follows:

[0750] 8.8.3 Deblocking Filtering Process

[0751] 8.8.3.1 Conventional

[0752] The deblocking filtering process is applied to all codec sub-block edges and transform block edges of the image, except for the following types of edges:

[0753] - The edges on the boundary of the image,

[0754] – Edges that coincide with the boundaries of subpicks that have a subpick index `subpicIdx` and a `loop_filter_across_subpic_enabled_flag[subpicIdx]` equal to 0.

[0755] – When VirtualBoundariesPresentFlag equals 1, the edges that coincide with the virtual boundaries of the image.

[0756] – Edges that coincide with tile boundaries when loop_filter_cross_tiles_enabled_flag is equal to 0

[0757] – The edge that coincides with the slice boundary when loop_filter_cross_slices_enabled_flag equals 0

[0758] – with slice_deblocking_filter_ [[disabled]]_flag equals [[1]] The edge where the upper or left boundary of the strip coincides.

[0759] –slice_deblocking_filter_ [[disabled]]_flag equals [[1]] The edge within the strip,

[0760] – Edges that do not correspond to the boundaries of the 4×4 sample grid for the brightness component.

[0761] – Edges that do not correspond to the boundaries of the 8×8 sample grid for chromaticity components

[0762] – Edges in the luminance component where intra_bdpcm_luma_flag is equal to 1 on both sides.

[0763] – Edges in the chroma component where intra_bdpcm_chroma_flag is equal to 1 on both sides.

[0764] – The edge of a chromatic sub-block that is not the edge of a correlated transform unit.

[0765] The vertical or horizontal edge type is represented by the variable edge type, as specified in Table 42.

[0766] Table 42 – Names associated with edgeType

[0767]

[0768] When the current slice_deblocking_filter_ [[disabled]]_flag equals [[0]] The following applies:

[0769] – The variable treeType is set to equal DUAL_TREE_LUMA.

[0770] – Vertical edges are filtered by calling a deblocking filtering process in one direction as specified in Clause 8.8.3.2, where the variable treeType and the reconstructed image before deblocking (i.e., the array recPicture) are used. L The reconstructed image (i.e., the array recPicture) is modified after deblocking and takes the variable edgeType, set to equal EDGE_VER, as input. L ) as output.

[0771] – Horizontal edges are filtered by calling a deblocking filtering process in one direction as specified in Clause 8.8.3.2, where the variable treeType and the modified reconstructed image after deblocking (i.e., the array recPicture) are used. L The reconstructed image (i.e., the array recPicture) is taken as input and the variable edgeType, which is set to equal EDGE_HOR. L ) as output.

[0772] – When ChromaArrayType is not equal to 0, the following applies:

[0773] – The variable treeType is set to equal DUAL_TREE_CHROMA

[0774] – Vertical edges are filtered by calling a deblocking filtering process in one direction as specified in Clause 8.8.3.2, where the variable treeType and the reconstructed image before deblocking (i.e., the array recPicture) are used. Cb and recPicture Cr The image is a reconstructed image (i.e., an array recPicture) with the variable edgeType set to equal EDGE_VER as input and modified after deblocking. Cb and recPicture Cr ) as output.

[0775] – Horizontal edges are filtered by calling a deblocking filtering process in one direction as specified in Clause 8.8.3.2, where the variable treeType and the reconstructed image after deblocking (i.e., the array recPicture) are used. Cb and recPicture Cr The image is a reconstructed image (i.e., an array recPicture) with the variable edgeType set to equal EDGE_HOR as input and the modified image after deblocking. Cb and recPicture Cr ) as output.

[0776] 6.1.5. Examples of Items 1.d, 1.g, 1.j, and 1.f

[0777] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0778]

[0779]

[0780] A value of 1 indicates that the `ph_deblocking_filter_override_flag` exists in the PH of the reference PPS, or that the `slice_deblocking_filter_override_flag` exists in the slice header of the reference PPS. A value of 0 indicates that the `ph_deblocking_filter_override_enabled_flag` does not exist in the PH of the reference PPS, [[or]]. The slice_deblocking_filter_override_flag is missing from the reference PPS slice header. When it is missing, the value of deblocking_filter_override_enabled_flag is inferred to be equal to 0.

[0781] A value of 1 indicates that the deblocking filter operation should not be applied to slices of PPS where `slice_deblocking_filter_disabled_flag` does not exist. A value of 0 indicates that the deblocking filter operation should be applied to slices of PPS where `slice_deblocking_filter_disabled_flag` does not exist. When it does not exist, the value of `pps_deblocking_filter_disabled_flag` is inferred to be 0.

[0782] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0783]

[0784]

[0785] Furthermore, the syntax structure slice_header() has been changed as follows:

[0786]

[0787]

[0788] A value of 1 indicates that the deblocking parameter exists in the slice header. A value of 0 indicates that the deblocking parameter does not exist in the slice header. When it does not exist, the value of slice_deblocking_filter_override_flag is inferred to be equal to [[ph_deblocking_filter_override_flag]].

[0789] 6.1.6. Another embodiment of items 1.d, 1.g, 1.j, 1.e, and 1.n

[0790] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0791]

[0792]

[0793] A value of 1 indicates that the `ph_deblocking_filter_override_flag` exists in the PH of the reference PPS, or that the `slice_deblocking_filter_override_flag` exists in the slice header of the reference PPS. A value of 0 indicates that the `ph_deblocking_filter_override_enabled_flag` does not exist in the PH of the reference PPS, [[or]]. The `slice_deblocking_filter_override_flag` flag is not present in the reference PPS strip header. When it is absent, the value of `deblocking_filter_override_enabled_flag` is inferred to be 0.

[0794] A value of 1 for `pps_deblocking_filter_disabled_flag` indicates that the deblocking filter operation should not be applied to slices of PPS where `slice_deblocking_filter_disabled_flag` does not exist. A value of 0 for `pps_deblocking_filter_disabled_flag` indicates that the deblocking filter operation should be applied to slices of PPS where `slice_deblocking_filter_disabled_flag` does not exist. When it does not exist, the value of `pps_deblocking_filter_disabled_flag` is inferred to be 0.

[0795] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0796]

[0797]

[0798] Furthermore, the syntax structure slice_header() has been changed as follows:

[0799]

[0800]

[0801] A value of 1 indicates that the deblocking parameter exists in the slice header. A value of 0 indicates that the deblocking parameter does not exist in the slice header. When it does not exist, the value of slice_deblocking_filter_override_flag is inferred to be equal to [[ph_deblocking_filter_override_flag]].

[0802] 6.1.7. Another embodiment of items 1.d, 1.g, 1.j, 1.f, 1.h, and 1.k

[0803] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0804]

[0805]

[0806]

[0807] A value of 1 indicates the presence of the deblocking filter control syntax element in PPS. A value of 0 indicates the absence of the deblocking filter control syntax element in PPS.

[0808] A value of 1 indicates that the deblocking filter operation should not be applied to slices of PPS in which the slice_deblocking_filter_disabled_flag is absent. A value of 0 indicates that the deblocking filter operation should be applied to slices of PPS in which the slice_deblocking_filter_disabled_flag is absent. When the slice_deblocking_filter_disabled_flag is absent, its value is inferred to be 0.

[0809] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0810]

[0811]

[0812] Equals [[1]] The deblocking filter operation is specified to be excluded from pH-related stripes, ph_deblocking_filter_[[disabled]]. _flag equals [[0]] The deblocking filter operation is specified to apply to strips associated with pH, ​​when ph_deblocking_filter_[[disabled]]. If _flag does not exist, it is inferred to be equal to pps_deblocking_filter_[[disabled]]. _flag.

[0813] Furthermore, the syntax structure slice_header() has been changed as follows:

[0814]

[0815]

[0816] A value of 1 indicates that the deblocking parameter exists in the slice header. A value of 0 indicates that the deblocking parameter does not exist in the slice header. When it does not exist, the value of slice_deblocking_filter_override_flag is inferred to be equal to [[ph_deblocking_filter_override_flag]].

[0817] Equals [[1]] The deblocking filter operation is specified to not apply to the current slice. `slice_deblocking_filter_[[disabled]]` _flag equals [[0]] This specifies the operation for applying the deblocking filter to the current slice. When slice_deblocking_filter_[[disabled]]... If _flag does not exist, it is inferred to be equal to [[PPS]]. _deblocking_filter_[[disabled]] _flag.

[0818] 6.2. Second set of embodiments

[0819] This is a set of embodiments of items 2, 2.a and 2.b outlined in Section 5 above.

[0820] 8.5.6.3 Fractional Sample Interpolation Process

[0821] 8.5.6.3.1 Conventional

[0822] The input to this process is:

[0823] – Luminance position (xSb, ySb), specifies the top-left sample of the current codec sub-block relative to the top-left luminance sample of the current image.

[0824] – The variable sbWidth specifies the width of the current encoded / decoded sub-block.

[0825] – A variable sbHeight that specifies the height of the current encoded / decoded sub-block.

[0826] – Motion vector offset mvOffset

[0827] – Precise motion vector refMvLX

[0828] – The selected reference image sample array refPicLX

[0829] – Half-sample interpolation filter exponent hpelIfIdx,

[0830] –

[0831] – Decoder-side motion vector refinement flag dmvrFlag

[0832] – Bidirectional optical flow flag bdofFlag

[0833] – The variable refPicIsScaled indicates whether the selected reference image needs to be scaled.

[0834] – The variable cIdx specifies the color component index of the current block.

[0835] - A list of horizontal and vertical scaling ratios.

[0836] The output of this process is:

[0837] – The array predSamplesLX, representing the predicted sample values ​​(sbWidth+brdExtSize)x(sbHeight+brdExtSize).

[0838] The derivation of the predicted block boundary extension size brdExtSize is as follows:

[0839] brdExtSize=(bdofFlag||[[(inter_affine_flag[xSb][ySb]&&!ph_disable_prof_flag)]] ? 2:0 (934)

[0840] The variable refWraparoundEnabledFlag is set to equal to (pps_ref_wraparound_enabled_flag && !refPicIsScaled).

[0841] The variable fRefLeftOffset is set to equal to ((SubWidthC*scaling_win_left_offset)<<10), where scaling_win_left_offset is the scaling_win_left_offset of the reference image.

[0842] The variable fRefTopOffset is set to equal to ((SubWidthC*scaling_win_top_offset)<<10), where scaling_win_top_offset is the scaling_win_top_offset of the reference image.

[0843] The derivation of the array predSamplesLX, which represents the predicted sample values ​​(sbWidth + brdExtSize) x (sbHeight + brdExtSize), is as follows:

[0844] – The motion vector mvLX is set to (refMvLX-mvOffset).

[0845] – If cIdx equals 0, then the following applies:

[0846] – Let (xInt) L yInt L ) is the brightness position given in full sample units, and (xFrac) L yFrac LThe offset is given in 1 / 16 sample unit. These variables are used only in this clause to specify the fractional sample positions within the reference sample array refPicLX.

[0847] – Top-left coordinates of the boundary block filled with reference samples (xSbInt) L ySbInt L ) is set to equal to (xSb+(mvLX[0]>>4), ySb+(mvLX[1]>>4)).

[0848] – For each brightness sample location (x L =0..sb width-1+brdExtSize,y L =0..sbHeight-1+brdExtSize), then the corresponding predicted brightness sample value predSamplesLX[x L ][y L The derivation of ] is as follows:

[0849] – Let (refxSb) L ,refySb L ) and (refx L refy L ) represents the brightness position in units of 1 / 16 samples, pointed to by the motion vector (refMvLX[0], refMvLX[1]). The variable refxSb L refx L ,refySb L and refy L The derivation is as follows:

[0850] refxSb L =(((xSb-(SubWidthC*scaling_win_left_offset))<<4)+refMvLX[0])*scalingRatio[0] (935)

[0851] refx L =((Sign(refxSb) L )*((Abs(refxSb L )+128)>>8)+x L *((scalingRatio[0]+8)>>4))+fRefLeftOffset+32)>>6 (936)

[0852] refySb L=(((ySb-(SubWidthC*scaling_win_top_offset))<<4)+refMvLX[1])*scalingRatio[1] (937)

[0853] refy L =((Sign(refySb) L )*((Abs(refySb L )+128)>>8)+yL*((scalingRatio[1]+8)>>4))+fRefTopOffset+32)>>6 (938)

[0854] – Variable xInt L yInt L xFrac L and yFrac L The derivation is as follows:

[0855] xInt L =refx L >>4 (939)

[0856] yInt L =refy L >>4 (940)

[0857] xFrac L =refx L &15 (941)

[0858] yFrac L =refy L &15 (942)

[0859] –Predicted luminance sample values ​​predSamplesLX[x] L ][y L The export of ] is as follows:

[0860] – If bdofFlag equals TRUE or [[(ph_disable_prof_flag equals FALSE, and inter_affine_flag[xSb][ySb]]]] If the value is TRUE[[)]] and one or more of the following conditions are TRUE, then the predicted luminance sample value predSamplesLX[x] is derived by invoking the luminance integer sample extraction procedure specified in Clause 8.5.6.3.3. L ][y L ], where (xInt L +(xFrac L>>3)-1), yInt L +(yFrac L >>3)-1), refPicLX and refWraparoundEnabledFlag are used as inputs.

[0861] -x L It equals 0.

[0862] -x L It equals sbWidth+1.

[0863] –y L It equals 0.

[0864] –y L It equals sbHeight + 1.

[0865] Otherwise, the predicted luminance sample values ​​predSamplesLX[xL][yL] are obtained by invoking the luminance sample 8-tap interpolation filtering procedure specified in Clause 8.5.6.3.2, where (xIntL - (brdExtSize>0?1:0), yIntL - (brdExtSize>0?1:0)), (xFracL, yFracL), (xSbInt) L ,ySbInt L ), refPicLX, hpelIfIdx, sbWidth, sbHeight, dmvrFlag, refWraparoundEnabledFlag, scalingRatio[0], scalingRatio[1] and (xSb,ySb) are used as inputs.

[0866] Otherwise (cIdx is not equal to 0), the following applies:

[0867] …

[0868] 6.3. Third set of embodiments

[0869] This is a set of embodiments of items 3, 3.a, 3.b and 3.c as outlined in Section 5 above.

[0870] 6.3.1. Example of item 3.a

[0871] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0872]

[0873]

[0874] A value of 1 for `pps_pic_slice_luma_qp_delta_present_flag` indicates that either `ph_qp_delta` exists in the PH of the reference PPS, or the `slice_qp_delta` syntax element exists in the slice header of the reference PPS. A value of 0 for `pps_pic_slice_luma_qp_delta_present_flag` indicates that neither `ph_qp_delta` exists in the PH of the reference PPS, nor the `slice_qp_delta` syntax element exists in the slice header of the reference PPS.

[0875] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0876]

[0877] Furthermore, the syntax structure slice_header() has been changed as follows:

[0878]

[0879]

[0880] 6.3.2. Example of item 3.b

[0881] In one example, the syntax structure pic_parameter_set_rbsp() is modified as follows:

[0882]

[0883] The rule of equal to 1 The `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements exist in the associated slice header. The setting `pps_slice_chroma_qp_offsets_present_flag` to 0 specifies... The `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements are not present in the associated slice header. When they are not present, the value of `pps_slice_chroma_qp_offsets_present_flag` is inferred to be 0.

[0884]

[0885] Furthermore, the syntax structure of picture_header_structure() has been changed as follows:

[0886]

[0887]

[0888]

[0889] Furthermore, the syntax structure slice_header() has been changed as follows:

[0890]

[0891] The rule is to determine Qp' Cb The value of the quantization parameter should be added to the difference between the values ​​of pps_cb_qp_offset and pps_cb_qp_offset. The value of slice_cb_qp_offset should be in the range of -12 to +12 (inclusive). When slice_cb_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_cb_qp_offset+slice_cb_qp_offset should be in the range of -12 to +12 (inclusive).

[0892] The rule is to determine Qp' Cr The value of the quantization parameter should be added to the difference between the values ​​of pps_cr_qp_offset and pps_cr_qp_offset. The value of slice_cr_qp_offset should be in the range of -12 to +12 (inclusive). When slice_cr_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_Cr_qp_offset+slice_Cr_qp_offset should be in the range of -12 to +12 (inclusive).

[0893] The rule is to determine Qp' CbCr The value to be added is the difference between the values ​​of pps_joint_cbcr_qp_offset_value and the values ​​of slice_joint_cbcr_qp_offset. The value of slice_joint_cbcr_qp_offset should be in the range of -12 to +12 (inclusive). When slice_joint_cbcr_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_joint_cbcr_qp_offset_value + slice_joint_cbcr_qp_offset should be in the range of -12 to +12 (inclusive).

[0894] 6.3.3. Example of item 3.c

[0895] The changes to bold and italic text markings are based on JVET-Q2001-vE.

[0896]

[0897]

[0898]

[0899] The rule of equal to 1 The `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements exist in the associated slice header. The setting `pps_slice_chroma_qp_offsets_present_flag` to 0 specifies... The `slice_cb_qp_offset` and `slice_cr_qp_offset` syntax elements are not present in the associated slice header. When they are not present, the value of `pps_slice_chroma_qp_offsets_present_flag` is inferred to be 0.

[0900] The rule of equal to 1 QP Incremental Information It exists within the PH syntax structure, but not in the stripe header of a PPS that does not contain a PH syntax structure. `qp_delta_info_in_ph_flag` equal to 0 specifies the QP increment. It does not exist in the PH syntax structure, but it can exist in the strip header of a PPS that does not contain a PH syntax structure.

[0901]

[0902]

[0903] The rule is to determine Qp' Cb The value of the quantization parameter is added to the difference between the values ​​of pps_cb_qp_offset and the quantization parameter. The value of slice_cb_qp_offset should be in the range of -12 to +12 (inclusive). When slice_cb_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_cb_qp_offset+slice_cb_qp_offset should be in the range of -12 to +12 (inclusive).

[0904] The rule is to determine Qp' Cr The value of the quantization parameter is added to the difference between the values ​​of pps_cr_qp_offset and the quantization parameter. The value of slice_cr_qp_offset should be in the range of -12 to +12 (inclusive). When slice_cr_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_cr_qp_offset + slice_cr_qp_offset should be in the range of -12 to +12 (inclusive).

[0905] The rule is to determine Qp' CbCr The value to be added is the difference between the values ​​of pps_joint_cbcr_qp_offset_value and the values ​​of slice_joint_cbcr_qp_offset. The value of slice_joint_cbcr_qp_offset should be in the range of -12 to +12 (inclusive). When slice_joint_cbcr_qp_offset does not exist, it is inferred to be equal to [[0]]. The value of pps_joint_cbcr_qp_offset_value + slice_joint_cbcr_qp_offset should be in the range of -12 to +12 (inclusive).

[0906] 6.4. Fourth Group of Examples

[0907] This is a set of examples of items 4, 4.a, 4.b, 4.c and 4.d outlined in Section 5 above.

[0908] This specifies the maximum cbSubdiv value for the intra-slice codec unit that transmits cu_qp_delta_abs and cu_qp_delta_sign_flag. The value of ph_cu_qp_delta_subdiv_intra_slice should be between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY[[+ph_max_mtt_hierarchy_depth_intra_slice_luma]])+ Within the range of (including endpoints).

[0909] When it does not exist, the value of ph_cu_qp_delta_subdiv_intra_slice is inferred to be equal to 0.

[0910] This specifies the maximum cbSubdiv value of the codec unit in the intra-slice transmitting cu_chroma_qp_offset_flag. The value of ph_cu_chroma_qp_offset_subdiv_intra_slice should be between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY[[+ph_max_mtt_hierarchy_depth_intra_slice_luma]])+ Within the range of (including endpoints).

[0911] When it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_intra_slice is inferred to be equal to 0.

[0912] This specifies the maximum cbSubdiv value for the codec unit in the inter-frame slice transmitting cu_qp_delta_abs and cu_qp_delta_sign_flag. The value of ph_cu_qp_delta_subdiv_inter_slice should be between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeInterY[[+ph_max_mtt_hierarchy_depth_inter_slice]])+ Within the range of (including endpoints).

[0913] When it does not exist, the value of ph_cu_qp_delta_subdiv_inter_slice is inferred to be equal to 0.

[0914] This specifies the maximum cbSubdiv value of the codec unit in the inter-frame slice transmitting cu_chroma_qp_offset_flag. The value of ph_cu_chroma_qp_offset_subdiv_inter_slice should be between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeInterY[[+ph_max_mtt_hierarchy_depth_inter_slice]])+ Within the range of (including endpoints).

[0915] When it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_inter_slice is inferred to be equal to 0.

[0916] Figure 1 This is a block diagram of an example video processing system 1900 that can implement the various techniques disclosed herein. Various implementations may include some or all of the components in system 1900. System 1900 may include an input 1902 for receiving video content. The video content may be received in a raw or uncompressed format (e.g., 8 or 10-bit multi-component pixel values), or in a compressed or encoded format. Input 1902 may represent a network interface, a peripheral bus interface, or a storage interface. Examples of network interfaces include wired interfaces (such as Ethernet, Passive Optical Networking (PON), etc.) and wireless interfaces (such as Wi-Fi or cellular interfaces).

[0917] System 1900 may include a codec component 1904 capable of implementing the various codec or encoding methods described in this document. Codec component 1904 can reduce the average bit rate of the video from input 1902 to the output of codec component 1904 to produce a codec representation of the video. Therefore, codec techniques are sometimes referred to as video compression or video transcoding techniques. The output of codec component 1904 can be stored or transmitted via connected communication, as represented by component 1906. The stored or communicated bitstream (or codec representation) of the video received at input 1902 can be used by component 1908 to generate pixel values ​​or displayable video that is sent to display interface 1910. The process of generating user-visible video from the bitstream is sometimes referred to as video decompression. Furthermore, although some video processing operations are referred to as “codec” operations or tools, it should be understood that the codec tool or operation is used at the encoder, and the corresponding decoding tool or operation will be inverted by the decoder to retrieve the result of the codec.

[0918] Examples of peripheral bus interfaces or display interfaces may include Universal Serial Bus (USB), High Definition Multimedia Interface (HDMI), or DisplayPort. Examples of storage interfaces include SATA (Serial Advanced Technology Accessory), PCI, IDE, etc. The technologies described in this document can be implemented in a variety of electronic devices, such as mobile phones, laptops, smartphones, or other devices capable of digital data processing and / or video display.

[0919] Figure 2This is a block diagram of a video processing apparatus 3600. Apparatus 3600 can be used to implement one or more of the methods described herein. Apparatus 3600 can be implemented in smartphones, tablets, computers, Internet of Things (IoT) receivers, etc. Apparatus 3600 may include one or more processors 3602, one or more memories 3604, and video processing circuitry 3606. The processors 3602(s) may be configured to implement one or more methods described herein. The memories 3604(s) may be used to store data and code used to implement the methods and techniques described herein. The video processing circuitry 3606 may be used to implement some of the techniques described herein in hardware circuitry.

[0920] Figure 4 This is a block diagram illustrating an example video codec system 100 that can utilize the techniques disclosed herein.

[0921] like Figure 4 As shown, the video encoding / decoding system 100 may include a source device 110 and a destination device 120. The source device 110 generates encoded video data and may be referred to as a video encoding device. The destination device 120 can decode the encoded video data generated by the source device 110 and may be referred to as a video decoding device.

[0922] The source device 110 may include a video source 112, a video encoder 114, and an input / output (I / O) interface 116.

[0923] Video source 112 may include sources such as video capture devices, interfaces for receiving video data from video content providers, and / or computer graphics systems that generate video data, or combinations of these sources. Video data may include one or more pictures. Video encoder 114 encodes the video data from video source 112 to generate a bitstream. The bitstream may include a sequence of bits forming a codec representation of the video data. The bitstream may include codec pictures and associated data. A codec picture is a codec representation of a picture. Associated data may include sequence parameter sets, picture parameter sets, and other syntax elements. I / O interface 116 includes a modulator / demodulator (modem) and / or a transmitter. Encoded video data may be transmitted directly to destination device 120 via network 130a through I / O interface 116. Encoded video data may also be stored on storage medium / server 130b for access by destination device 120.

[0924] Destination device 120 may include I / O interface 126, video decoder 124 and display device 122.

[0925] I / O interface 126 may include a receiver and / or a modem. I / O interface 126 may acquire encoded video data from source device 110 or storage medium / server 130b. Video decoder 124 may decode the encoded video data. Display device 122 may display the decoded video data to a user. Display device 122 may be integrated with destination device 120 or may be external to destination device 120 configured to connect to an external display device.

[0926] The video encoder 114 and the video decoder 124 can operate according to video compression standards such as High Efficiency Video Codec (HEVC), Multi-Functional Video Codec (VVC), and other current and / or other standards.

[0927] Figure 5 This is a block diagram illustrating an example of a video encoder 200, which may be... Figure 4 The video encoder 114 in the system 100 shown in the figure.

[0928] The video encoder 200 can be configured to perform any or all of the techniques disclosed herein. Figure 5 In the example, the video encoder 200 includes multiple functional components. The techniques described in this disclosure can be shared among the various components of the video encoder 200. In some examples, the processor can be configured to perform any or all of the techniques described in this disclosure.

[0929] The functional components of the video encoder 200 may include a segmentation unit 201, a prediction unit 202 (which may include a mode selection unit 203, a motion estimation unit 204, a motion compensation unit 205, and an intra-frame prediction unit 206), a residual generation unit 207, a transform unit 208, a quantization unit 209, an inverse quantization unit 210, an inverse transform unit 211, a reconstruction unit 212, a buffer 213, and an entropy coding unit 214.

[0930] In other examples, the video encoder 200 may include more, fewer, or different functional components. In one example, the prediction unit 202 may include an intra-block copy (IBC) unit. The IBC unit may perform prediction in IBC mode, where at least one reference picture is the picture in which the current video block is located.

[0931] Furthermore, some components, such as the motion estimation unit 204 and the motion compensation unit 205, can be highly integrated, but for interpretive purposes... Figure 5 The examples are shown separately.

[0932] The segmentation unit 201 can segment an image into one or more video blocks. The video encoder 200 and the video decoder 300 can support various video block sizes.

[0933] The mode selection unit 203 can, for example, select one of the intra-frame or inter-frame encoding / decoding modes based on the error result, and provide the obtained intra-frame or inter-frame encoded / decoded blocks to the residual generation unit 207 to generate residual block data and to the reconstruction unit 212 to reconstruct the encoded blocks for use as reference images. In some examples, the mode selection unit 203 can select a combined intra-frame and inter-frame prediction (CIIP) mode, where the prediction is based on the inter-frame prediction signal and the intra-frame prediction signal. The mode selection unit 203 can also select the resolution of the motion vector (e.g., sub-pixel or full-pixel precision) for the blocks in the inter-frame prediction case.

[0934] To perform inter-frame prediction for the current video block, motion estimation unit 204 can generate motion information for the current video block by comparing one or more reference frames from buffer 213 with the current video block. Motion compensation unit 205 can determine the predicted video block for the current video block based on the motion information of the image from buffer 213 (rather than the image associated with the current video block) and decoded samples.

[0935] The motion estimation unit 204 and the motion compensation unit 205 can perform different operations on the current video block, for example, the different operations performed depend on whether the current video block is in an I-strip, a P-strip, or a B-strip.

[0936] In some examples, motion estimation unit 204 can perform unidirectional prediction of the current video block, and can search for a reference video block for the current video block in the reference images of list 0 or list 1. Motion estimation unit 204 can then generate a reference index indicating that the reference image in list 0 or list 1 contains the reference video block, and a motion vector indicating the spatial displacement between the current video block and the reference video block. Motion estimation unit 204 can output the reference index, prediction direction indicator, and motion vector as motion information for the current video block. Motion compensation unit 205 can generate a predicted video block for the current block based on the reference video block indicated by the motion information of the current video block.

[0937] In other examples, motion estimation unit 204 can perform bidirectional prediction of the current video block. Motion estimation unit 204 can search for a reference video block for the current video block in the reference images of list 0 and can also search for another reference video block for the current video block in the reference images of list 1. Motion estimation unit 204 can then generate a reference index indicating that the reference images in list 0 or list 1 contain the reference video block, and a motion vector indicating the spatial displacement between the reference video block and the current video block. Motion estimation unit 204 can output the reference index and the motion vector of the current video block as the motion information of the current video block. Motion compensation unit 205 can generate a predicted video block for the current video block based on the reference video block indicated by the motion information of the current video block.

[0938] In some examples, the motion estimation unit 204 can output the complete set of motion information for the decoder's decoding process.

[0939] In some examples, motion estimation unit 204 may not output the complete set of motion information for the current video. Instead, motion estimation unit 204 may signal the motion information of the current video block by referencing the motion information of another video block. For example, motion estimation unit 204 may determine that the motion information of the current video block is sufficiently similar to the motion information of neighboring video blocks.

[0940] In one example, the motion estimation unit 204 may indicate in the syntax structure associated with the current video block that the current video block has the same motion information value as another video block.

[0941] In another example, motion estimation unit 204 can identify another video block and motion vector difference (MVD) in the syntax structure associated with the current video block. The motion vector difference indicates the difference between the motion vector of the current video block and the motion vector of the indicating video block. Video decoder 300 can use the motion vector of the indicating video block and the motion vector difference to determine the motion vector of the current video block.

[0942] As discussed above, the video encoder 200 can predictively signal motion vectors. Two examples of predictive signaling notification techniques that can be implemented by the video encoder 200 include Advanced Motion Vector Prediction (AMVP) and merge pattern signaling notification.

[0943] Intra-prediction unit 206 can perform intra-prediction on the current video block. When intra-prediction unit 206 performs intra-prediction on the current video block, it can generate prediction data for the current video block based on decoded samples from other video blocks in the same frame. The prediction data for the current video block can include the predicted video block and various syntax elements.

[0944] The residual generation unit 207 can generate residual data for the current video block by subtracting (e.g., indicated by a minus sign) multiple predicted video blocks from the current video block. The residual data for the current video block can include residual video blocks corresponding to different sample components of the samples in the current video block.

[0945] In other examples, such as in skip mode, residual data for the current video block may not exist, and the residual generation unit 207 may not perform a subtraction operation.

[0946] The transform processing unit 208 can generate one or more transform coefficient video blocks of the current video block by applying one or more transforms to the residual video block associated with the current video block.

[0947] After the transform processing unit 208 generates a transform coefficient video block associated with the current video block, the quantization unit 209 can quantize the transform coefficient video block associated with the current video block based on one or more quantization parameter (QP) values ​​associated with the current video block.

[0948] The inverse quantization unit 210 and the inverse transform unit 211 can apply inverse quantization and inverse transform to the transform coefficient video block respectively to reconstruct the residual video block from the transform coefficient video block. The reconstruction unit 212 can add the reconstructed residual video block to the corresponding samples of one or more predicted video blocks generated by the prediction unit 202 to produce a reconstructed video block associated with the current block for storage in the buffer 213.

[0949] After the video block is reconstructed in reconstruction unit 212, a loop filtering operation can be performed to reduce video block artifacts in the video block.

[0950] Entropy encoding unit 214 can receive data from other functional components of video encoder 200. When entropy encoding unit 214 receives data, it can perform one or more entropy encoding operations to generate entropy encoded data and output a bitstream including the entropy encoded data.

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

[0952] Figure 6 This is a block diagram illustrating an example of a video decoder 300, which may be... Figure 4 The video decoder 114 in the system 100 shown in the figure.

[0953] The video decoder 300 can be configured to perform any or all of the techniques disclosed herein. Figure 6 In the example, the video decoder 300 includes multiple functional components. The techniques described in this disclosure can be shared among the various components of the video decoder 300. In some examples, the processor can be configured to perform any or all of the techniques described in this disclosure.

[0954] exist Figure 6 In the example, the video decoder 300 includes an entropy decoding unit 301, a motion compensation unit 302, an intra-frame prediction unit 303, an inverse quantization unit 304, an inverse transform unit 305, a reconstruction unit 306, and a buffer 307. In some examples, the video decoder 300 can perform operations related to the video encoder 200 ( Figure 5 The decoding process is the overall inversion of the encoding process described.

[0955] Entropy decoding unit 301 can retrieve the encoded bitstream. The encoded bitstream may include entropy-encoded video data (e.g., encoded blocks of video data). Entropy decoding unit 301 can decode the entropy-encoded video, and based on the entropy-encoded video data, motion compensation unit 302 can determine motion information including motion vectors, motion vector precision, reference image list index, and other motion information. Motion compensation unit 302 can determine such information, for example, by performing AMVP and merge modes.

[0956] The motion compensation unit 302 can generate motion compensation blocks, possibly based on interpolation filters. The identifier of the interpolation filter to be used at sub-pixel precision can be included in the syntax element.

[0957] The motion compensation unit 302 can use the interpolation filter used by the video encoder 200 during the encoding of the video block to calculate the interpolation values ​​of a sub-integer number of pixels of the reference block. The motion compensation unit 302 can determine the interpolation filter used by the video encoder 200 based on the received syntax information and use the interpolation filter to generate the prediction block.

[0958] The motion compensation unit 302 can use some syntactic information to determine: the size of the blocks used to encode (multiple) frames and / or (multiple) stripes of the encoded video sequence, segmentation information describing how each macroblock of the image of the encoded video sequence is segmented, a mode indicating how each segment is encoded, one or more reference frames (and a list of reference frames) for each inter-frame coded block, and other information for decoding the encoded video sequence.

[0959] Intra-prediction unit 303 can use, for example, an intra-prediction mode received in the bitstream to form prediction blocks from spatially adjacent blocks. Inverse quantization unit 303 inverse quantizes (i.e., dequantizes) the quantized video block coefficients provided in the bitstream and decoded by entropy decoding unit 301. Inverse transform unit 303 applies an inverse transform.

[0960] The reconstruction unit 306 can sum the residual blocks using the corresponding prediction blocks generated by the motion compensation unit 202 or the intra-frame prediction unit 303 to form a decoded block. As desired, a deblocking filter can also be applied to filter the decoded block to remove blocking artifacts. The decoded video block is then stored in a buffer 307, which provides a reference block for subsequent motion compensation / intra-frame prediction and also produces the decoded video for presentation on the display device.

[0961] The following sections describe the example PROF technique, the exemplary affine merge technique, and the example affine AMVP technique:

[0962] PROF: Predictive Refinement Using Optical Flow (PROF) is used to refine sub-block-based affine motion compensation predictions. After performing sub-block-based affine motion compensation, the luminance prediction samples are refined by adding differences derived from the optical flow equation. Thus, for example, the PROF technique involves refining sub-block-based affine motion compensation predictions for a video block, followed by refining the luminance prediction samples of the video block by adding differences derived from the optical flow equation.

[0963] Affine merge: In this mode, the CPMV (Control Point Motion Vector) of the current CU is generated based on the motion information of spatially adjacent CUs. Several CPMVP (Control Point Motion Vector Predictions) candidates are constructed from the motion information of spatially adjacent CUs. Signaling informs an index to indicate the index to be used for the current CU. Thus, for example, in affine merge mode, the control point motion vector of the current codec unit of the video block is generated based on the motion information of the spatially adjacent codec units of the current codec unit, and the index indicating the affine merge candidate from the list of sub-block merge candidates to be used for the current codec unit is included in the bitstream.

[0964] Affine AMVP: A signaling flag at the CU level is used in the bitstream to indicate whether the affine AMVP mode is used, followed by a signaling flag indicating whether 4-parameter or 6-parameter affine is used. In this mode, the difference between the current CU's CPMV and its predictor CPMVP is signaled in the bitstream. Thus, for example, the affine AMVP mode includes in the bitstream: (1) an affine flag at the codec unit level of the video block to indicate whether the affine advanced motion vector prediction mode is used, (2) a second flag to indicate whether 4-parameter or 6-parameter affine is used, (3) a control point motion vector predictor index at the codec unit level, and (4) the difference between the control point motion vector of the current codec unit of the video block and the predictor control point motion vector corresponding to the control point motion vector.

[0965] The following is a list of preferred solutions for some embodiments.

[0966] The following solutions illustrate example embodiments of the techniques discussed in the preceding sections (e.g., items 1.1 to 1.c).

[0967] 1. A video processing method (e.g., Figure 3 The method 3000 shown includes: performing a conversion between videos comprising one or more video images, the one or more video images comprising one or more video strips, wherein the conversion conforms to a first rule that specifies that a determination of the applicability of a deblocking filter for a set of parameters of one or more video strips for reference to the video images is performed based on a deblocking syntax field included in the image header of the respective video image.

[0968] 2. The method of Solution 1, wherein the decision is based on whether the video picture parameter set and picture header are disabled based on applicability, and also based on the disabled strip level indication of the deblocking filter.

[0969] 3. The method of any one of solutions 1-2, wherein the transformation also conforms to the second rule, which allows for the applicability of signaling notifications that cover higher-level deblocking filters in the codec representation based on a more refined level of signaling notification or derived flags than the higher level in the codec representation.

[0970] 4. The method of Solution 1, wherein whether the flag is signaled or exported depends on another field included in the codec representation.

[0971] The following solutions illustrate example embodiments of the techniques discussed in the preceding sections (e.g., items 1.d to 1.q).

[0972] 5. A video processing method comprising: performing a conversion between videos including one or more video images, the one or more video images including one or more video stripes, wherein the conversion conforms to a rule that specifies the applicability of a deblocking filter for the video stripes based on fields included at the strip header level and / or picture header level and / or picture parameter set level in the video stripes.

[0973] 6. The approach of Solution 5, wherein the rule specifies a constraint that if the deblocking filter is disabled based on signaling notification at the image parameter set level, the deblocking filter cannot be enabled by signaling notification at the strip header level or the image header level.

[0974] 7. The approach of Solution 5, wherein the rule specifies a constraint that allows signaling notifications at the strip header level or image header level to disable the deblocking filter for video stripes when the deblocking filter is enabled based on signaling notifications at the image parameter set level.

[0975] 8. The method of Solution 5, wherein the rule specifies that the value of the first field controlling the enabling of the deblocking filter at the image parameter set level is independent of the value of the second field indicating whether the deblocking filter is covered.

[0976] 9. The method of Solution 5, wherein the rule specifies that the signaling notification of the syntax element "dbf_info_in_ph_flag" included in the image parameter set is independent of other syntax elements including deblocking_filter_override_enabled_flag, and the syntax element "dbf_info_in_ph_flag" specifies whether the deblocking filter on / off control parameters and / or deblocking filter parameters exist in the image header or sequence header.

[0977] 10. Solution 5's approach, in which the rule specifies that the overlay flag at the image parameter set level, image level, or stripe level does not control the overlay of the block on / off control parameter.

[0978] 11. The method of Solution 5, wherein the rule specifies that an overlay flag at the picture parameter set level or the picture level or the strip level is used to overlay the on / off control parameters or filter parameters of the deblocking filter, rather than both.

[0979] 12. Solution 5's approach, in which the rule specifies that deblocking filters can be enabled at the image level or stripe level even if deblocking filters are disabled at the image parameter set level.

[0980] 13. The method of Solution 5, wherein the rule specifies that fields controlling the on / off state of the deblocking filter and fields indicating the parameters of the deblocking filter are included at both the image level and the strip level.

[0981] 14. The method of Solution 5, wherein the rule specifies that the fields controlling the on / off state of the deblocking filter and the fields indicating the parameters of the deblocking filter are included in the sequence parameter set.

[0982] 15. The method of Solution 5, wherein the applicability of the deblocking filter for video stripes is signaled in a syntax field, which is signaled at the video unit level, wherein the syntax field is not a binary flag, and wherein the video unit level includes a set of picture parameters or a set of sequence parameters.

[0983] 16. The method of Solution 15, wherein the syntax field includes N bits, where N is an integer greater than 1.

[0984] 17. The method of Solution 16, wherein N = 2, and wherein the syntax field indicates four options, including one or more of the following: (a) the deblocking filter is not applied to all slices of the reference picture parameter set (PPS), (b) the deblocking filter is applied to all slices of the reference PPS using a first offset parameter notified in the signaling in the PPS, (c) the deblocking filter is applied to all slices of the reference PPS using a second offset parameter notified in the signaling in the PPS, or (d) the deblocking filter is applied to the slices of the reference PPS by means of parameters other than those notified in the signaling in the PPS.

[0985] 18. Solution 5, wherein the rule specifies that the deblocking filter is enabled by using a zero value for the deblocking filter parameter for the video stripe.

[0986] The following solutions illustrate example embodiments of the techniques discussed in the preceding section (e.g., item 2).

[0987] 19. A video processing method comprising: determining the applicability of prediction refinement-based optical flow (PROF) coding and decoding to affine high-level motion vector prediction coding and decoding based on a first rule or affine merge mode based on a second rule; and performing a conversion between video blocks of the video and the codec representation of the video according to the determination.

[0988] 20. The method of Solution 1, wherein the second rule specifies that PROF encoding and decoding are applied to the video block such that the prediction block corresponding to the M*N part is greater than M*N, where M and N are positive integers.

[0989] 21. The method of any one of solutions 19-20, wherein a flag in the codec representation is included to indicate the number of extended samples generated by the prediction block generated by the PROF codec.

[0990] 22. The method of Solution 21, wherein the number of expanded samples is the same for both the first and second rules.

[0991] The following solutions illustrate example embodiments of the techniques discussed in the preceding section (e.g., item 3).

[0992] 23. A video processing method comprising: performing a conversion between a video comprising one or more pictures containing one or more stripes and a codec representation of the video, wherein a first syntax element at the picture level or stripe level and / or a second syntax element at another level indicating quantization parameter increments or offset signaling notifications are conditionally included in the codec representation according to rules.

[0993] 24. The method of Solution 23, wherein the rule specifies that another level is a sequence parameter set level or a picture parameter set level, and wherein the second syntax element indicates whether chroma increment QP signaling notification or luminance increment QP signaling notification is enabled.

[0994] 25. The method of Solution 23, wherein the rule specifies that another level is the sequence parameter set level or the picture parameter set level, and wherein the second syntax element indicates whether chroma QP offset signaling notification is enabled.

[0995] The following solutions illustrate example embodiments of the techniques discussed in the previous section (e.g., item 4).

[0996] 26. A video processing method comprising: performing a conversion between a video comprising one or more images containing one or more stripes and a codec representation of the video, wherein the codec representation includes a syntax element indicating codec subdivision values ​​(cbSubDiv), the range of which is based on a rule.

[0997] 27. The method of Solution 26, wherein the rule specifies a range independent of the syntax field ph_max_mtt_hierarchy_depth_intra_slice_luma included in the codec representation.

[0998] 28. The method of any one of solutions 26-27, wherein the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive).

[0999] 29. The approach of Solution 26, wherein the rule specifies a range independent of the ph_max_mtt_hierarchy_depth_intra_slice_luma field.

[1000] 30. The approach of Solution 26, wherein the rule specifies the range independently of the ph_max_mtt_hierarchy_depth_inter_slice field.

[1001] 31. The method of any one of solutions 1 to 30, wherein the conversion includes encoding the video into a codec representation.

[1002] 32. The method of any one of solutions 1 to 30, wherein the conversion includes decoding the encoding / decoding representation to generate pixel values ​​of the video.

[1003] 33. A video decoding apparatus, comprising a processor configured to implement the method described in one or more of solutions 1 to 32.

[1004] 34. A video encoding apparatus comprising a processor configured to implement the method described in one or more of solutions 1 to 32.

[1005] 35. A computer program product having computer code stored thereon, which, when executed by a processor, causes the processor to implement the method of any one of solutions 1 to 32.

[1006] 36. The methods, apparatus or systems described in this document.

[1007] Figure 7 This is a flowchart of an example method 700 for video processing. Operation 702 includes performing a conversion between a video and a video bitstream comprising an image containing one or more stripes, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to one or more stripes of a reference image parameter set at least based on a first syntax element included in the image parameter set, and wherein the first syntax element indicates whether the deblocking filter is disabled for the image.

[1008] In some embodiments of method 700, the rule specifying whether to apply a deblocking filter to one or more stripes of a reference picture parameter set is based on at least one of the following: (1) whether the deblocking filter is disabled for the picture by a second syntax element in the picture header, (2) whether the deblocking filter is disabled by a third syntax element at the stripe level, or (3) whether a fourth syntax element in the picture parameter set indicates whether coverage of the deblocking filter applicability is disabled at both the picture and stripe levels. In some embodiments of method 700, the rule specifying whether to apply a deblocking filter to one or more stripes of a reference picture parameter set is based on: (1) whether the deblocking filter is disabled for the picture by a second syntax element in the picture header, and (2) whether the deblocking filter is indicated to be disabled by a third syntax element at the stripe level. In some embodiments of method 700, a value of 1 for the first, second, and third syntax elements indicates that the deblocking filter is disabled.

[1009] In some embodiments of method 700, the rule specifying whether to apply a deblocking filter to one or more stripes of a reference picture parameter set is further based on whether a fourth syntax element in the picture parameter set indicates whether coverage of the applicability of the deblocking filter is disabled at both the picture and stripe levels. In some embodiments of method 700, a first value of 1 for the first syntax element indicates that the deblocking filter is disabled for the pictures of the reference picture parameter set, and a second value of 0 for the fourth syntax element indicates that coverage of the applicability of the deblocking filter is disabled at both the picture and stripe levels. In some embodiments of method 700, a value of 1 for the first syntax element and a value of 0 for the fourth syntax element indicate that the deblocking filter is disabled.

[1010] Figure 8 This is a flowchart of an example method 800 for video processing. Operation 802 includes performing a conversion between a video and a video bitstream comprising images containing one or more stripes, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to one or more stripes of a reference image parameter set based solely on syntax elements included in the image parameter set indicating whether the deblocking filter is disabled.

[1011] In some embodiments of method 800, the value of the syntax element being equal to 1 indicates that the deblocking filter is disabled for the image.

[1012] Figure 9This is a flowchart of an example method 900 for video processing. Operation 902 includes performing a conversion between a video and a video bitstream comprising one or more images containing one or more stripes, wherein the bitstream conforms to a rule that specifies whether to override a deblocking operation on a stripe or image at the stripe level or the image level based on a first value of a first syntax element at the stripe level or a second value of a second syntax element at the image level, and wherein the rule specifies that, in response to the absence of a first syntax element in the stripe header, the first value of the first syntax element is determined independently of the second value of the second syntax element at the image level.

[1013] In some embodiments of method 900, a first value of the first syntax element is determined to be 0, indicating that the deblocking operation is not covered at the stripe level. In some embodiments of method 800, a second value of the second syntax element is determined to be 0, indicating that the deblocking operation is not covered at the picture level.

[1014] Figure 10 This is a flowchart of an example method 1000 for video processing. Operation 1002 includes performing a conversion between a video comprising one or more images containing one or more stripes and a bitstream of the video, wherein the bitstream conforms to a rule that specifies whether a deblocking parameter is included in a stripe header or an image header based on a first value of a first syntax element at the stripe level or a second value of a second syntax element at the image level, and wherein the rule specifies that, in response to the absence of a first syntax element in the stripe header, the first value of the first syntax element is determined independently of the second value of the second syntax element at the image level.

[1015] In some embodiments of method 1000, a first value of the first syntax element is determined to be 0, which indicates that the deblocking parameter is not included at the strip level. In some embodiments of method 1000, a second value of the second syntax element is determined to be 0, which indicates that the deblocking parameter is not included at the picture level.

[1016] Figure 11 This is a flowchart of an example method 1100 for video processing. Operation 1102 includes performing a conversion between a video comprising one or more pictures containing one or more stripes and a bitstream of the video, wherein the bitstream conforms to a format rule specifying whether a first syntax element and a second syntax element are included in the picture header and stripe header, respectively, or whether they are inferred based on the value of a third syntax element in the picture parameter set, wherein the first syntax element indicates whether a deblocking filter is disabled at the picture level of the video, wherein the second syntax element indicates whether a deblocking filter is disabled at the stripe level of the video, and wherein the third syntax element indicates whether a deblocking filter is enabled for one or more pictures in the reference picture parameter set.

[1017] Figure 12 This is a flowchart of an example method 1200 for video processing. Operation 1202 includes performing a conversion between a video comprising one or more pictures containing one or more stripes and the bitstream of that video, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to a stripe based on syntax elements included in the stripe header and / or picture header and / or picture parameter set referenced by the stripe, and wherein the syntax elements indicate whether the deblocking filter is enabled at the picture parameter set level and / or the stripe level and / or the picture level.

[1018] In some embodiments of method 1200, the rule specifies that if the deblocking filter is disabled according to a first syntax element in the picture parameter set, then enabling the deblocking filter by a second syntax element in the strip header or a third syntax element in the picture header is not permitted. In some embodiments of method 1200, the rule further specifies that the presence of the second syntax element in the strip header and / or the third syntax element in the picture header is based on a first value of the first syntax element and independent of a second value of a flag indicating whether coverage of the applicability of enabling the deblocking filter at the picture level or the strip level is enabled. In some embodiments of method 1200, the rule specifies that in response to the first syntax element indicating that the deblocking filter is disabled for stripes of the reference picture parameter set, the second syntax element and / or the third syntax element are excluded from the strip header and / or the picture header, respectively. In some embodiments of method 1200, the rule further specifies flags in the picture parameter set indicating: (1) whether a first syntax element is indicated in the picture parameter set, whether a second syntax element is indicated in the strip header, and / or whether a third syntax element is indicated in the picture, and (2) whether the parameters of the deblocking filter are indicated in the picture parameter set, the picture header, and the strip header. In some embodiments of method 1200, flags indicate: (1) that a first syntax element is excluded from the picture parameter set, a second syntax element is excluded from the strip header, and / or a third syntax element is excluded from the picture, and (2) that the parameters used for the deblocking filter are excluded from the picture parameter set, the picture header, and the strip header.

[1019] In some embodiments of method 1200, the rule specifies that if the deblocking filter is disabled based on a first syntax element not present in the image parameter set, then enabling the deblocking filter by a second syntax element in the stripe header or a third syntax element in the image header is not permitted, and it is inferred that the first syntax element is equal to a specific value. In some embodiments of method 1200, the rule specifies that if the deblocking filter is disabled based on a first syntax element in the image parameter set, then enabling the deblocking filter by a second syntax element in the stripe header or a third syntax element not present in the image header is not permitted, and it is inferred that the third syntax element has the same value as the first syntax element. In some embodiments of method 1200, the rule specifies that if the deblocking filter is disabled based on a first syntax element in the image parameter set, enabling the deblocking filter by a second syntax element not present in the stripe header or a third syntax element in the image header is not permitted, and it is inferred that the second syntax element has the same value as the first syntax element or the third syntax element. In some embodiments of method 1200, the rule specifies that if the deblocking filter is enabled at a first video unit level of the video, then disabling the deblocking filter at a second video unit level of the video is permitted, where the second video unit level is lower than the first video unit level.

[1020] In some embodiments of method 1200, the first video unit level includes a picture header, and the second video unit level includes a stripe header. In some embodiments of method 1200, one or more pictures include multiple stripes, the multiple stripes including a first group of one or more stripes and a second group of one or more stripes, the rule specifying that a deblocking filter is enabled for the first group of one or more stripes, and the rule specifying that a deblocking filter is disabled for the second group of one or more stripes. In some embodiments of method 1200, a first syntax element included in the stripe header indicates whether a deblocking filter is enabled at the second video unit level, a second syntax element in the picture header indicates whether a deblocking filter is enabled at the first video unit level, and the rule specifies that the first syntax element is based on the second syntax element. In some embodiments of method 1200, the rule specifies that, if the first syntax element indicates that a deblocking filter is enabled for the current picture, the second syntax element indicates whether a deblocking filter is enabled for the current stripe of the current picture. In some embodiments of method 1200, the rule also specifies whether the picture parameter set includes a syntax element indicating a deblocking filter and / or whether the parameters are included in the stripe header or picture header, a first flag independent of one or more other syntax elements. In some embodiments of method 1200, one or more other syntax elements include a second flag indicating whether coverage of the applicability of the deblocking filter is enabled at both the picture level and the stripe level.

[1021] In some embodiments of method 1200, the rule specifies that whether a second syntax element is included in the strip header or whether a third syntax element is included in the picture header is based on a first flag and / or a first syntax element in the picture parameter set and is independent of the second flag. The first syntax element indicates whether a deblocking filter is enabled for strips of a reference picture parameter set, the second syntax element indicates whether the deblocking filter is enabled at the strip level, and the third syntax element indicates whether the deblocking filter is enabled at the picture level. In some embodiments of method 1200, the first flag in the picture parameter set or the second flag in the strip header or the third flag in the picture header respectively indicates whether coverage of deblocking filter applicability is enabled at the picture parameter set level or the picture level or the strip level, and the rule also specifies that the first flag or the second flag or the third flag is configured only to cover the parameters of the deblocking filter, except for: (1) a first syntax element in the picture parameter set indicating whether the deblocking filter is enabled at the picture parameter set level, or (2) a second syntax element in the strip header indicating whether the deblocking filter is enabled at the strip level, or (3) a third syntax element in the picture header indicating whether the deblocking filter is enabled at the picture level. In some embodiments of method 1200, according to the rule, a first syntax element is selectively included in the picture parameter set preceding the first flag, or according to the rule, a second syntax element is selectively included in the strip header preceding the second flag, or according to the rule, a third syntax element is selectively included in the picture header preceding the third flag, and the rule specifies whether the first flag, the second flag, or the third flag is included in the picture parameter set, the strip header, or the picture header, respectively, based on the first syntax element, the second syntax element, or the third syntax element, respectively.

[1022] In some embodiments of method 1200, the syntax element includes a first syntax element, and the rule further specifies that the picture parameter set includes a first syntax element indicating whether a deblocking filter is enabled for one or more stripes of the reference picture parameter set. In some embodiments of method 1200, the rule further specifies whether the picture parameter set includes a first syntax element independent of one or more other syntax elements in the picture parameter set, the first syntax element indicating whether a deblocking filter is enabled for one or more stripes of the reference picture parameter set. In some embodiments of method 1200, the rule further specifies that if the deblocking filter is disabled at a first video unit level of the video, one or more syntax elements at a second video unit level of the video are absent and inferred to be equal to the value indicating that the deblocking filter is disabled by the first syntax element at the first video unit level, and the first video unit level is higher than the second video unit level. In some embodiments of method 1200, the rule also specifies a syntax element in the picture parameter set indicating the presence of global control of the deblocking filter, the syntax element being configured only to control the presence of: (1) one or more flags in the picture parameter set or picture header or strip header indicating whether coverage of the applicability of the deblocking filter is enabled at the picture parameter set level or picture level or strip level, and (2) the parameters of the deblocking filter in the picture parameter set, picture header or strip header.

[1023] In some embodiments of method 1200, the rule further specifies that a flag indicates whether coverage is enabled for the applicability of the deblocking filter or for the first set of parameters of the deblocking filter. In some embodiments of method 1200, the flag is included in a picture parameter set or a picture header or a strip header. In some embodiments of method 1200, the rule further specifies that, when the flag indicates whether coverage is enabled for the applicability of the deblocking filter, then: (1) the first set of parameters of the deblocking filter is included only at the first video unit level of the video, and (2) in response to enabling the deblocking filter at the second video unit level, the second set of parameters of the deblocking filter at the second video unit level of the video is inferred from the first set of parameters of the deblocking filter at the first video unit level, wherein the first video unit level is higher than the second video unit level. In some embodiments of method 1200, the rule further specifies that, when a flag indicates whether overriding is enabled for a first set of parameters of a deblocking filter included in a first video unit level of the video, then: (1) the applicability of the deblocking filter is limited to the first video unit level, and (2) in response to enabling the deblocking filter for a second video unit level, a second set of parameters of a deblocking filter for a second video unit level of the video is inferred from the first set of parameters of the deblocking filter at the first video unit level, wherein the first video unit level is higher than the second video unit level.

[1024] In some embodiments of method 1200, the first video unit level includes a set of picture parameters, and the second video unit level includes a picture header or a stripe header. In some embodiments of method 1200, the syntax elements include a first syntax element for the first video unit level and a second syntax element for the second video unit level, wherein the first and second syntax elements respectively indicate whether a deblocking filter is enabled at the first and second video unit levels, wherein the first video unit level is higher than the second video unit level, and wherein the rule further specifies that, in response to the first syntax element indicating that the deblocking filter is disabled at the first video unit level, overriding of the second syntax element is not allowed. In some embodiments of method 1200, the first video unit level includes a set of picture parameters, and the second video unit level includes a picture header or a stripe header. In some embodiments of method 1200, the rule specifies whether the second syntax element is included in the second video unit level based on whether the first syntax element indicates that the deblocking filter is allowed to be controlled at the first video unit level.

[1025] In some embodiments of method 1200, the syntax element includes a first syntax element at the first video unit level and a second syntax element at the second video unit level, the first and second syntax elements indicating whether a deblocking filter is enabled at the first and second video unit levels, respectively, and the rule specifies that in response to the absence of the second syntax element at the second video unit level, the deblocking filter is inferred to have a specific state at the second video unit level. In some embodiments of method 1200, the specific state includes disabled, enabled, or the same as the state of the deblocking filter indicated by the first syntax element. In some embodiments of method 1200, the rule specifies that the picture parameter set does not include a syntax element indicating the presence of global control for the deblocking filter, the rule specifies that the picture parameter set includes a first syntax element indicating whether the deblocking filter is enabled, and the first syntax element is independent of this syntax element. In some embodiments of method 1200, the second syntax element indicates whether the applicability of overriding the deblocking filter is allowed, wherein the rule specifies whether the picture parameter set includes the second syntax element based on the first syntax element indicating that the deblocking filter is enabled. In some embodiments of method 1200, the rule specifies whether the parameters of the deblocking filter are included in the image parameter set based on a second syntax element that indicates the applicability of the deblocking filter.

[1026] In some embodiments of method 1200, the rule specifies that the image parameter set does not include a syntax element indicating the presence of global control over the deblocking filter. The rule specifies that the image parameter set includes a first syntax element indicating whether coverage of the deblocking filter's applicability is allowed, and the first syntax element is independent of this syntax element. In some embodiments of method 1200, a second syntax element indicates whether the deblocking filter is enabled. The rule specifies that whether the image parameter set includes the second syntax element is based on the first syntax element indicating that coverage of the deblocking filter's applicability is allowed. In some embodiments of method 1200, the rule specifies that whether the parameters of the deblocking filter are included in the image parameter set is based on a second syntax element indicating that the deblocking filter is enabled. In some embodiments of method 1200, the rule specifies that the image header includes a syntax element indicating whether the image header or stripe header includes one or more syntax elements indicating whether the deblocking filter is enabled and / or the parameters of the deblocking filter.

[1027] In some embodiments of method 1200, the rule specifies that syntax elements be excluded from the image parameter set. In some embodiments of method 1200, the rule specifies that each of the image header and stripe header includes one or more syntax elements indicating whether the deblocking filter is enabled and / or parameters of the deblocking filter.

[1028] Figure 13 This is a flowchart of an example method 1300 for video processing. Operation 1302 includes performing a conversion between a video comprising one or more images containing one or more stripes and the bitstream of that video, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to a stripe based on syntax elements included in a sequence parameter set referenced by the stripe, and wherein the syntax elements include a first syntax element indicating whether the deblocking filter is enabled and / or a set of syntax elements indicating a first set of parameters for the deblocking filter.

[1029] In some embodiments of method 1300, the rule further specifies that a first syntax element in the sequence parameter set at the first video unit level of the video is overridden by a second syntax element indicating whether deblocking filter is enabled at the second video unit level of the video, and the first video unit level is higher than the second video unit level.

[1030] In some embodiments of method 1300, the rule further specifies that a first set of parameters of the deblocking filter indicated in the sequence parameter set at a first video unit level of the video is overridden by a second set of parameters of the deblocking filter indicated at a second video unit level of the video, and the first video unit level is higher than the second video unit level. In some embodiments of method 1300, the second video unit level includes a picture parameter set, a picture header, or a stripe header.

[1031] Figure 14 This is a flowchart of an example method 1400 for video processing. Operation 1402 includes performing a conversion between a video comprising one or more images containing one or more stripes and the bitstream of that video, wherein the conversion conforms to a rule specifying whether a deblocking filter is applied to a stripe based on a non-binary syntax element included at the video unit level, and wherein the non-binary syntax element indicates whether and / or how the deblocking filter is applied to one or more stripes.

[1032] In some embodiments of method 1400, the video unit level includes a picture parameter set or a sequence parameter set. In some embodiments of method 1400, a rule specifies that a non-binary syntax element indicates a deblocking mode, and wherein the non-binary syntax element includes N bits. In some embodiments of method 1400, N = 2. In some embodiments of method 1400, the rule specifies that a first value of the non-binary syntax element indicates that the deblocking filter is not applied to all slices of the reference picture parameter set; a second value of the non-binary syntax element indicates that a deblocking parameter offset of 0 values ​​for β and tC is used, and the deblocking filter is applied to all slices of the reference picture parameter set; a third value of the non-binary syntax element indicates that a deblocking parameter offset explicitly included in the picture parameter set for β and tC is used, and the deblocking filter is applied to all slices of the reference picture parameter set; and a fourth value of the non-binary syntax element indicates that whether the deblocking filter is applied to a slice of the reference picture parameter set is controlled by parameters present in the slice's picture header or slice header. In some embodiments of method 1400, the rule specifies whether the parameters of the deblocking filter are included in the image parameter set based on the values ​​of non-binary syntax elements.

[1033] In some embodiments of method 1400, the rule specifies that, in response to a value that satisfies a specific condition, the parameters of the deblocking filter are included in the image parameter set, and in response to a value that does not satisfy the specific condition, the parameters of the deblocking filter are inferred to be 0. In some embodiments of method 1400, the specific condition includes whether the value is greater than an integer. In some embodiments of method 1400, the rule specifies that the value of a non-binary syntax element controls whether a syntax element is included in the image parameter set, and the syntax element specifies whether the image header or stripe header includes a syntax element indicating whether the deblocking filter is enabled and / or the parameters of the deblocking filter. In some embodiments of method 1400, the rule specifies that, in response to a value of a non-binary syntax element that satisfies a specific condition, the syntax element is included in the image parameter set. In some embodiments of method 1400, the specific condition includes whether the value is equal to an integer. In some embodiments of method 1400, the rule specifies that, in response to the syntax element being excluded from the image parameter set, the syntax element is inferred to have a specific value. In some embodiments of method 1400, the rule specifies that the value of the non-binary syntax element controls whether the syntax element is included in the picture header or strip header, and the syntax element indicates whether the deblocking filter is enabled and / or the parameters of the deblocking filter.

[1034] In some embodiments of method 1400, the rule specifies that, in response to the value of a non-binary syntax element that satisfies a specific condition, a syntax element in the picture header indicates whether a deblocking filter is enabled at the picture level of the video. In some embodiments of method 1400, the rule specifies that, in response to the value of a non-binary syntax element that satisfies a specific condition, a syntax element in the stripe header indicates whether a deblocking filter is enabled at the stripe level of the video. In some embodiments of method 1400, the specific condition includes whether the value is equal to an integer.

[1035] Figure 15 This is a flowchart of an example method 1500 for video processing. Operation 1502 includes performing a conversion between a video comprising one or more pictures containing one or more stripes and a bitstream of that video, wherein the conversion conforms to the following rules: (1) enabling a deblocking filter at the picture level or stripe level of the video, and (2) using the zero-value deblocking parameter offsets of β and tC as parameters of the deblocking filter.

[1036] In some embodiments of method 1500, the rule specifies that the picture parameter set includes one or more syntax elements indicating whether the default parameters of the deblocking filter are associated with a zero-value deblocking parameter offset for β and tC, or with user-defined β and tC offsets. In some embodiments of method 1500, in response to one or more syntax elements indicating that the default parameters of the deblocking filter are associated with user-defined β and tC offsets, the picture parameter set includes user-defined β and tC offsets. In some embodiments of method 1500, the parameters of the deblocking filter and the default parameters of the deblocking filter are selectively overridden at the picture level or the stripe level of the video. In some embodiments of method 1500, the rule specifies that the video unit level of the video includes one or more syntax elements indicating whether a zero-value deblocking parameter offset for β and tC is used or whether a user-defined β and tC offset is used. In some embodiments of method 1500, in response to one or more syntax elements indicating the use of user-defined β and tC offsets, the video unit level includes user-defined β and tC offsets. In some embodiments of method 1500, the video unit level includes a sequence parameter set, a picture parameter set, a picture header, or a strip header.

[1037] Figure 16 This is a flowchart of an example method 1600 for video processing. Operation 1602 includes determining the size of a predicted block corresponding to a video block for conversion between video blocks and the video bitstream according to rules. Operation 1604 includes performing a conversion based on this determination, wherein the rules specify a first size of the predicted block in response to whether a prediction refinement technique using optical flow is used to encode and decode the video block, and wherein the video block has a second size and is encoded and decoded using an affine merge mode or an affine advanced motion vector prediction mode.

[1038] In some embodiments of method 1600, the first width and first height of the first size of the prediction block are indicated by (M+M0) and (N+N0), respectively, and the second width and second height of the second size of the video block are indicated by M and N, respectively, with M0 greater than or equal to 0 and N0 greater than or equal to 0. In some embodiments of method 1600, M0 and N0 are not both equal to 0. In some embodiments of method 1600, M0 and N0 are equal to 2. In some embodiments of method 1600, a flag indicating whether a prediction refinement technique using optical flow is utilized controls whether and / or how many extended samples are included in the prediction block of the first size. In some embodiments of method 1600, the first size of the prediction block is based on the number of extended samples, and the number of extended samples is independent of whether the first video block is encoded and decoded using an affine merge mode or according to an affine high-level motion vector prediction mode. In some embodiments of method 1600, the first width and first height of the first size of the predicted block are indicated by (M+X) and (N+Y), respectively, the second width and second height of the second size of the video block are indicated by M and N, respectively, and X is the number of expanded samples of the width. Y is the number of expanded samples of the height. In some embodiments of method 1600, X and Y are equal to 0. In some embodiments of method 1600, X and Y are equal to 2.

[1039] In some embodiments of method 1600, X and Y are equal to 2 in response to the value of a flag indicating that a prediction refinement technique using optical flow is utilized. In some embodiments of method 1600, the value of the flag is equal to 1. In some embodiments of method 1600, the first size of the prediction block is based on a boundary expansion size, which is based on the value of a flag indicating whether a prediction refinement technique using optical flow is utilized, and the boundary expansion size indicates that a second size of the video block is increased by the number of expanded samples to obtain the first size of the prediction block. In some embodiments of method 1600, the number of expanded samples is 0. In some embodiments of method 1600, the number of expanded samples is 2. In some embodiments of method 1600, the prediction refinement technique using optical flow includes refining a sub-block-based affine motion-compensated prediction of the video block, followed by refining the luminance prediction samples of the video block by adding differences derived from the optical flow equation. In some embodiments of method 1600, the affine merge mode includes generating a control point motion vector for the current codec unit of a video block based on motion information of spatially adjacent codec units of the current codec unit, and including in the bitstream an index indicating an affine merge candidate from a list of sub-block merge candidates for the current codec unit. In some embodiments of method 1600, the affine advanced motion vector prediction mode includes in the bitstream: (1) an affine flag at the codec unit level of the video block indicating whether the affine advanced motion vector prediction mode is used, (2) a second flag indicating whether a 4-parameter affine or a 6-parameter affine is used, (3) a control point motion vector prediction value index at the codec unit level, and (4) the difference between the control point motion vector of the current codec unit of the video block and the predicted control point motion vector corresponding to the control point motion vector.

[1040] Figure 17 This is a flowchart of example method 1700 for video processing. Operation 1702 includes performing a conversion between a video and a video bitstream comprising one or more pictures containing one or more stripes, wherein a rule specifies that a first syntax element is indicated at the video level above the picture level or stripe level, and wherein the first syntax element indicates whether the picture level or stripe level includes quantization parameter increments.

[1041] In some embodiments of method 1700, the video level is a sequence parameter set level or a picture parameter set level, and the first syntax element indicates whether the picture level or stripe level is enabled to include a luminance quantization parameter increment or a chrominance quantization parameter increment. In some embodiments of method 1700, the rule specifies that whether a luminance quantization parameter increment is included in the picture header and / or stripe header is based on a first syntax element indicating the presence of the luminance quantization parameter increment. In some embodiments of method 1700, the rule specifies that, in response to a first syntax element indicating that the luminance quantization parameter increment does not exist at the picture level or stripe level, the luminance quantization parameter increment is not allowed to be included in the picture header and stripe header. In some embodiments of method 1700, the rule specifies that, in response to a first syntax element indicating that the luminance quantization parameter increment does not exist at the picture level or stripe level, the luminance quantization parameter increment is not allowed to be included in the picture header or stripe header. In some embodiments of method 1700, the rule specifies that, in response to the luminance quantization parameter increment not existing in the picture header, the luminance quantization parameter increment is inferred to have a specific value. In some embodiments of method 1700, the rule specifies that, in response to the luma quantization parameter increment not being present in the strip header, the luma quantization parameter increment is inferred to have a specific value. In some embodiments of method 1700, the rule specifies that the first syntax element controls whether the picture parameter set includes a flag specifying whether the luma quantization parameter increment is included in the picture header or strip header. In some embodiments of method 1700, the rule specifies that, in response to the first syntax element indicating that the luma quantization parameter increment is not present in the picture level or strip level, the flag is excluded from the picture parameter set. In some embodiments of method 1700, the rule specifies that, in response to the flag not being present in the picture parameter set, the flag is inferred to have a specific value.

[1042] Figure 18 This is a flowchart of example method 1800 for video processing. Operation 1802 includes performing a conversion between a video comprising one or more pictures containing one or more stripes and the bitstream of that video, wherein a first rule specifies a first flag in a first video level indicating whether one or more chroma metric parameter offsets are included in the first video level, wherein the first video level is higher than the stripe level, wherein a second rule specifies a second flag in a second video level indicating whether one or more chroma metric parameter offsets are included in the picture header or stripe header, and wherein the second video level is higher than the picture level.

[1043] In some embodiments of method 1800, a second rule specifies that a second flag in the image parameter set indicates whether one or more colorimetric parameter offsets are included in the image header or strip header. In some embodiments of method 1800, the second rule specifies that, in response to a second flag indicating that one or more colorimetric parameter offsets are included in the image header, one or more colorimetric parameter offsets are excluded from the strip header. In some embodiments of method 1800, the second rule specifies that, in response to a second flag indicating that one or more colorimetric parameter offsets are excluded from the image header, one or more colorimetric parameter offsets are selectively included in the strip header. In some embodiments of method 1800, in response to one or more colorimetric parameter offsets being excluded from the image header, one or more colorimetric parameter offsets in the image header are inferred to be a specific value. In some embodiments of method 1800, in response to one or more colorimetric parameter offsets being excluded from the strip header, one or more colorimetric parameter offsets in the strip header are inferred to be a specific value. In some embodiments of method 1800, the second rule specifies that the second flag also indicates whether the brightness quantization parameter increment is included in the image header or the strip header.

[1044] In some embodiments of method 1800, the second rule specifies that a second flag in the sequence parameter set and / or picture parameter set indicates whether one or more colorimetric parameter offsets are included in the picture header and / or stripe header. In some embodiments of method 1800, the second rule specifies that, in response to the second flag indicating that one or more colorimetric parameter offsets do not exist at the picture level and stripe level, one or more colorimetric parameter offsets are not allowed to be included in the picture header and stripe header. In some embodiments of method 1800, the second rule specifies that a second flag controls whether another flag is included in the picture parameter set, wherein this other flag indicates whether one or more colorimetric parameter offsets are included at the picture level or stripe level. In some embodiments of method 1800, the second rule specifies that, in response to the second flag indicating that one or more colorimetric parameter offsets are excluded from the picture header or stripe header, the picture parameter set excludes the other flag. In some embodiments of method 1800, the second rule specifies that, in response to the absence of the other flag in the picture parameter set, the other flag is inferred to have a specific value. In some embodiments of method 1800, the second rule specifies that the quantization parameter increment and the colorimetric parameter offset are included in the same header. In some embodiments of method 1800, a second rule specifies that, in response to the quantization parameter increment being included in the image header, one or more colorimetric quantization parameter offsets are prohibited from being included in the strip header.

[1045] Figure 19 This is a flowchart of example method 1900A for video processing. Operation 1902A includes performing a conversion between a video and a bitstream of video comprising one or more pictures containing one or more stripes, wherein the bitstream includes a first syntax element indicating codec block segmentation values, and wherein the codec block segmentation values ​​have a range according to rules.

[1046] In some embodiments of method 1900A, the rule specifies that the range of codec block subdivision values ​​for codec units in an intra-strip that conveys cu_qp_delta_abs and cu_qp_delta_sign_flag is independent of a second syntax element in the bitstream that specifies the maximum hierarchical depth of the codec unit resulting from the multi-type tree partitioning of quad-leaf trees in the stripe. In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive). In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_intra_slice_luma,CtbLog2SizeY-MinCbLog2SizeY) (inclusive), and ph_max_mtt_hierarchy_depth_intra_slice_luma is the second syntax element.

[1047] In some embodiments of method 1900A, the rule specifies that the range of codec block subdivision values ​​for codec units in an intra-strip that conveys cu_chroma_qp_offset_flag is independent of a second syntax element in the bitstream that specifies the maximum hierarchical depth of the codec unit resulting from the multi-type tree partitioning of quad-leaf trees in the stripe. In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive). In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_intra_slice_luma,CtbLog2SizeY-MinCbLog2SizeY) (inclusive), and ph_max_mtt_hierarchy_depth_intra_slice_luma is a second syntax element. In some embodiments of method 1900A, the rule specifies that the range of codec block subdivision values ​​for codec units in an intra-strip transmitting cu_qp_delta_abs and cu_qp_delta_sign_flag is independent of the second syntax element in the bitstream, which specifies the maximum hierarchical depth of the codec unit resulting from the multi-type tree partitioning of quadtree leaves in the stripe. In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeInterY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive of end values). In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_inter_slice,CtbLog2SizeY-MinCbLog2SizeY) (inclusive of end values), and ph_max_mtt_hierarchy_depth_inter_slice is the second syntax element.

[1048] In some embodiments of method 1900A, the rule specifies that the range of codec block subdivision values ​​for codec units in an intra-strip transmitting cu_chroma_qp_offset_flag is independent of a second syntax element in the bitstream, which specifies the maximum hierarchical depth of the codec unit resulting from a multi-type tree partitioning of quadtree leaves in the stripe. In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeInterY)+2*(CtbLog2SizeY-MinCbLog2SizeY) (inclusive). In some embodiments of method 1900A, the rule specifies a range between 0 and 2*(CtbLog2SizeY-MinQtLog2SizeIntraY)+2*min(ph_max_mtt_hierarchy_depth_inter_slice,CtbLog2SizeY-MinCbLog2SizeY) (inclusive), and ph_max_mtt_hierarchy_depth_inter_slice is the second syntax element.

[1049] In some embodiments of methods 700-1900A, performing the conversion includes encoding video into a bitstream. In some embodiments of methods 700-1900A, performing the conversion includes generating a bitstream from video, and the method further includes storing the bitstream in a non-transitory computer-readable recording medium. In some embodiments of methods 700-1900A, performing the conversion includes decoding video from the bitstream. In some embodiments, a video decoding apparatus includes a processor configured to implement the operations of methods 700-1900A. In some embodiments, a video encoding apparatus includes a processor configured to implement the operations of methods 700-1900A. In some embodiments, a computer program product having computer instructions stored thereon, which, when executed by a processor, cause the processor to implement the operations of methods 700-1900A. In some embodiments, a non-transitory computer-readable storage medium stores a bitstream generated according to the operations of methods 700-1900A. In some embodiments, the non-transitory computer-readable storage medium stores instructions that cause the processor to implement the operations of methods 700-1900A. In some embodiments, a bitstream generation method includes: generating a video bitstream according to the operation of method 700-1900A, and storing the bitstream on a computer-readable program medium. In some embodiments, a bitstream generated according to the method, apparatus, disclosed method, or system described in this document.

[1050] In this document, the term "video processing" can refer to video encoding, video decoding, video compression, or video decompression. For example, a video compression algorithm can be applied during the conversion from the pixel representation of a video to the corresponding bitstream representation, and vice versa. As defined in the syntax, the bitstream representation of the current video block can, for example, correspond to bits that are co-occurring or scattered at different positions within the bitstream. For example, a macroblock can be encoded based on the error residuals from the transformation and encoding / decoding, and also using bits in the header and other fields in the bitstream. Furthermore, during the conversion, the decoder can, based on this determination, parse the bitstream knowing that some fields may or may not be present, as described in the solutions above. Similarly, the encoder can determine whether to include or exclude certain syntax fields and generate the codec representation accordingly by including or excluding syntax fields from the codec representation.

[1051] The disclosures and other schemes, examples, embodiments, modules, and functional operations described in this document can be implemented in digital electronic circuits or in computer software, firmware, or hardware, containing the structures disclosed in this document and their equivalents, or combinations thereof. The disclosed and other embodiments can be implemented as one or more computer program products encoded on a computer-readable medium, such as one or more computer program instruction modules, for execution by a data processing apparatus or for controlling the operation of a data processing apparatus. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a complex influencing machine-readable propagating signals, or combinations thereof. The term "data processing apparatus" encompasses all means, devices, and machines for processing data, including, for example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the apparatus may also include code that creates an execution environment for the computer program in question, such as code constituting processor firmware, a protocol stack, a database management system, an operating system, or combinations thereof. Propagating signals are artificially generated signals, such as machine-generated electrical, optical, or electromagnetic signals, which are generated to encode information for transmission to a suitable receiver device.

[1052] Computer programs (also known as programs, software, software applications, scripts, or code) can be written in any programming language, including compiled or interpreted languages, and can be deployed in any form, including standalone programs or modules, components, subroutines, or other units suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple co-located files (e.g., a file storing one or more modules, subroutines, or code portions). A computer program can be deployed to execute on one computer or on multiple computers located at a single site or distributed across multiple sites and interconnected by a communications network.

[1053] The processes and logic flows described in this document can be performed by one or more programmable processors executing one or more computer programs to perform functions by manipulating input data and generating outputs. The processes and logic flows can also be performed by special-purpose logic circuitry (e.g., field-programmable gate arrays (FPGAs) or application-specific integrated circuits (ASICs)), and the apparatus can be implemented as special-purpose logic circuitry (e.g., FPGAs or ASICs).

[1054] Processors suitable for executing computer programs include, for example, both general-purpose and special-purpose microprocessors, and any one or more processors in any type of digital computer. Typically, a processor receives instructions and data from read-only memory or random access memory, or both. The basic components of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, a computer will also include one or more mass storage devices (e.g., magneto-optical, magneto-optical, or optical disc) for storing data, or operatively coupled to receive data from or transfer data to a mass storage device (e.g., magneto-optical, magneto-optical, or optical disc), or both. However, a computer does not necessarily need to have such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, for example, semiconductor memory devices (e.g., EPROM, EEPROM, and flash memory devices); magnetic disks (e.g., internal hard disks or removable disks); magneto-optical disks; and CD-ROM and DVD-ROM disks. Processors and memory may be supplemented by or incorporated into special-purpose logic circuitry.

[1055] While this patent document contains numerous details, these details should not be construed as limiting any subject matter or the scope of the claims, but rather as descriptions of features specific to particular embodiments of a particular art. In this patent document, certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented separately in multiple embodiments or in various suitable sub-combinations. Furthermore, although features may be described above as operating in certain combinations and even initially claimed in the same manner, in certain circumstances one or more features from the claimed combination may be removed from the combination, and the claimed combination may be for sub-combinations or variations thereof.

[1056] Similarly, although operations are depicted in a specific order in the accompanying drawings, this should not be construed as requiring such operations to be performed in the specific order or sequence shown, or to perform all the operations shown, in order to achieve the desired result. Furthermore, the separation of various system components in the embodiments described in this patent document should not be construed as requiring such separation in all embodiments.

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

Claims

1. A method for processing video data, comprising: Perform conversion between a video containing one or more stripes of images and the bitstream of that video. The transformation conforms to a rule that specifies whether a deblocking filter is applied to the current strip of a reference image parameter set PPS is based at least on a first syntax element included in the image header PH associated with the current strip, wherein the current strip is one of one or more strips included in the image. The first syntax element indicates whether the deblocking filter is disabled for the image. The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set, and is based on at least one of the following: The second syntax element in the PPS indicates whether the deblocking filter is disabled for images referenced in the PPS, and The third syntax element in the stripe header SH indicates whether the deblocking filter is indicated as disabled, and Wherein, the first syntax element is ph_deblocking_filter_disabled_flag, and the second syntax element is pps_deblocking_filter_disabled_flag. Whether the ph_deblocking_filter_disabled_flag exists in the PH is based on the value of the pps_deblocking_filter_disabled_flag. When the value of the pps_deblocking_filter_disabled_flag is not equal to 1, the ph_deblocking_filter_disabled_flag exists in the PH. When the value of the pps_deblocking_filter_disabled_flag is equal to 1, the ph_deblocking_filter_disabled_flag does not exist in the PH.

2. The method according to claim 1, wherein, The rule specifying whether the deblocking filter is applied to the one or more stripes of the reference image parameter set is also based on at least one of the following: The fourth syntax element in the SH indicates whether to enable the overlay of the deblocking filter information at the stripe level, or The fifth syntax element in the PH indicates whether to enable the overlay of the deblocking filter information at the image level.

3. The method according to claim 1, wherein, The values ​​of the first syntax element, the second syntax element, and the third syntax element being equal to 1 indicate that the deblocking filter is disabled at the image level, PPS level, and stripe level, respectively.

4. The method according to claim 3, wherein, When the values ​​of the first syntax element, the second syntax element, and the third syntax element are equal to 1, the deblocking filter is disabled for the current stripe.

5. The method according to claim 1, wherein, The rule also stipulates that the existence of the third syntax element in the SH and / or the first syntax element in the PH is based on the value of the second syntax element in the PPS.

6. The method according to claim 1, wherein, Performing the conversion includes encoding the video into the bitstream.

7. The method according to claim 1, wherein, Performing the conversion includes decoding the video from the bitstream.

8. An apparatus for processing video data, comprising a processor and a non-transitory memory having instructions thereon, wherein, When the instruction is executed by the processor, the processor: Perform conversion between a video containing one or more stripes of images and the bitstream of that video. The transformation conforms to a rule specifying whether a deblocking filter is applied to the current stripe of the reference image parameter set PPS is based at least on a first syntax element included in the image header PH associated with the current stripe, wherein the current stripe is one of one or more stripes included in the image, and The first syntax element indicates whether the deblocking filter is disabled for the image; The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set, and is based on at least one of the following: The second syntax element in the PPS indicates whether the deblocking filter is disabled for images referenced in the PPS, and The third syntax element in the stripe header SH indicates whether the deblocking filter is indicated as disabled, and Wherein, the first syntax element is ph_deblocking_filter_disabled_flag, and the second syntax element is pps_deblocking_filter_disabled_flag. Whether the ph_deblocking_filter_disabled_flag exists in the PH is based on the value of the pps_deblocking_filter_disabled_flag. When the value of the pps_deblocking_filter_disabled_flag is not equal to 1, the ph_deblocking_filter_disabled_flag exists in the PH. When the value of the pps_deblocking_filter_disabled_flag is equal to 1, the ph_deblocking_filter_disabled_flag does not exist in the PH.

9. The apparatus according to claim 8, in, The values ​​of the first, second, and third syntax elements being equal to 1 indicate that the deblocking filter is disabled at the image level, PPS level, and stripe level, respectively. Specifically, when the values ​​of the first syntax element, the second syntax element, and the third syntax element are equal to 1, the deblocking filter is disabled for the current stripe.

10. The apparatus according to claim 8, wherein, The rule specifying whether the deblocking filter is applied to the one or more stripes of the reference image parameter set is also based on at least one of the following: The fourth syntax element in the SH indicates whether to enable the overlay of the deblocking filter information at the stripe level, or The fifth syntax element in the PH indicates whether to enable the overlay of the deblocking filter information at the image level.

11. The apparatus according to claim 8, wherein, The rule also stipulates that the existence of the third syntax element in the SH and / or the first syntax element in the PH is based on the value of the second syntax element in the PPS.

12. A non-transitory computer-readable storage medium for storing instructions, said instructions causing a processor to: Perform conversion between a video containing one or more stripes of images and the bitstream of that video. in, The transformation conforms to a rule specifying whether a deblocking filter is applied to the current stripe of the reference image parameter set PPS is based at least on a first syntax element included in the image header PH associated with the current stripe, wherein the current stripe is one of one or more stripes included in the image, and The first syntax element indicates whether the deblocking filter is disabled for the image; The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set, and is based on at least one of the following: The second syntax element in the PPS indicates whether the deblocking filter is disabled for images referenced in the PPS, and The third syntax element in the stripe header SH indicates whether the deblocking filter is indicated as disabled, and Wherein, the first syntax element is ph_deblocking_filter_disabled_flag, and the second syntax element is pps_deblocking_filter_disabled_flag. Whether the ph_deblocking_filter_disabled_flag exists in the PH is based on the value of the pps_deblocking_filter_disabled_flag. When the value of the pps_deblocking_filter_disabled_flag is not equal to 1, the ph_deblocking_filter_disabled_flag exists in the PH. When the value of the pps_deblocking_filter_disabled_flag is equal to 1, the ph_deblocking_filter_disabled_flag does not exist in the PH.

13. The non-transitory computer-readable storage medium according to claim 12, in, The values ​​of the first, second, and third syntax elements being equal to 1 indicate that the deblocking filter is disabled at the image level, PPS level, and stripe level, respectively. Specifically, when the values ​​of the first syntax element, the second syntax element, and the third syntax element are equal to 1, the deblocking filter is disabled for the current stripe.

14. The non-transitory computer-readable storage medium according to claim 12, wherein, The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set based on at least one of the following: a fourth syntax element in the SH, which indicates whether to enable the coverage of the deblocking filter information at the stripe level; or a fifth syntax element in the PH, which indicates whether to enable the coverage of the deblocking filter information at the image level. The rule further stipulates that the existence of the third syntax element in the SH and / or the first syntax element in the PH is based on the value of the second syntax element in the PPS.

15. A non-transitory computer-readable storage medium storing a computer program / instructions and a bitstream thereon, wherein the computer program / instructions, when executed by a processor, implement a method for processing video data to generate the bitstream, wherein the method includes: For a video that includes images containing one or more stripes, the bitstream is generated. The generation conforms to a rule specifying whether a deblocking filter is applied to the current stripe of the reference image parameter set PPS is based at least on a first syntax element included in the image header PH associated with the current stripe, wherein the current stripe is one of one or more stripes included in the image, and The first syntax element indicates whether the deblocking filter is disabled for the image; The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set, and is based on at least one of the following: The second syntax element in the PPS indicates whether the deblocking filter is disabled for images referenced in the PPS, and The third syntax element in the stripe header SH indicates whether the deblocking filter is indicated as disabled, and Wherein, the first syntax element is ph_deblocking_filter_disabled_flag, and the second syntax element is pps_deblocking_filter_disabled_flag. Whether the ph_deblocking_filter_disabled_flag exists in the PH is based on the value of the pps_deblocking_filter_disabled_flag. When the value of the pps_deblocking_filter_disabled_flag is not equal to 1, the ph_deblocking_filter_disabled_flag exists in the PH. When the value of the pps_deblocking_filter_disabled_flag is equal to 1, the ph_deblocking_filter_disabled_flag does not exist in the PH.

16. The non-transitory computer-readable storage medium according to claim 15, in, The values ​​of the first, second, and third syntax elements being equal to 1 indicate that the deblocking filter is disabled at the image level, PPS level, and stripe level, respectively. Specifically, when the values ​​of the first syntax element, the second syntax element, and the third syntax element are equal to 1, the deblocking filter is disabled for the current stripe.

17. The non-transitory computer-readable storage medium according to claim 15, wherein, The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set based on at least one of the following: a fourth syntax element in the SH, which indicates whether to enable the coverage of the deblocking filter information at the stripe level; or a fifth syntax element in the PH, which indicates whether to enable the coverage of the deblocking filter information at the image level. The rule further stipulates that the existence of the third syntax element in the SH and / or the first syntax element in the PH is based on the value of the second syntax element in the PPS.

18. A method for storing a video bitstream, comprising: For a video that includes images containing one or more stripes, generate a bitstream of the video. The bitstream is stored in a non-transitory computer-readable storage medium. The bitstream is generated by performing the following method: The generation conforms to a rule specifying whether a deblocking filter is applied to the current stripe of the reference image parameter set PPS is based at least on a first syntax element included in the image header PH associated with the current stripe, wherein the current stripe is one of one or more stripes included in the image, and The first syntax element indicates whether the deblocking filter is disabled for the image; The rule specifies whether the deblocking filter is applied to one or more stripes of the reference image parameter set, and is based on at least one of the following: The second syntax element in the PPS indicates whether the deblocking filter is disabled for images referenced in the PPS, and The third syntax element in the stripe header SH indicates whether the deblocking filter is indicated as disabled, and Wherein, the first syntax element is ph_deblocking_filter_disabled_flag, and the second syntax element is pps_deblocking_filter_disabled_flag. Whether the ph_deblocking_filter_disabled_flag exists in the PH is based on the value of the pps_deblocking_filter_disabled_flag. When the value of the pps_deblocking_filter_disabled_flag is not equal to 1, the ph_deblocking_filter_disabled_flag exists in the PH. When the value of the pps_deblocking_filter_disabled_flag is equal to 1, the ph_deblocking_filter_disabled_flag does not exist in the PH.

Images