Method, device and computer-readable storage medium for processing video data

Abstract

Techniques for video processing, including video encoding, decoding, and transcoding, are described. One example method includes performing conversion between a video picture comprising one or more slices and one or more rectangular strips and a video bitstream according to a rule. The rule specifies that, to iteratively determine information about the one or more rectangular strips, a variable indicating a slice index is updated only for slices having an index less than a value equal to the number of slices in the video picture minus one.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to and the benefit of International Patent Application No. PCT / CN2020 / 076158, filed on February 21, 2020, and International Patent Application No. PCT / CN2020 / 082283, filed on March 31, 2020. The entire disclosures of the above applications are incorporated by reference into this application. Technical Field

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

[0004] Digital video accounts for the largest use of bandwidth on the Internet and other digital communications networks. As the number of connected user devices capable of receiving and displaying video increases, bandwidth demand for digital video usage 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 codec representations of video using control information useful for decoding the codec representations.

[0006] In one example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and one or more rectangular strips and a bitstream of the video according to a rule. The rule specifies that, to iteratively determine information about the one or more rectangular strips, a variable indicating a slice index is updated only for slices having an index less than a value equal to the number of slices in the video picture minus 1.

[0007] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more sub-pictures and a bitstream of the video. The conversion complies with a rule that omits a syntax element in a sequence parameter set that indicates a number of sub-pictures in the video picture if a maximum picture width and a maximum picture height are equal to or less than dimensions of a codec treeblock.

[0008] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with a rule that omits a syntax element indicating the number of explicitly provided slice column widths in the bitstream if the width of the video picture is equal to or less than the dimensions of a codec treeblock.

[0009] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with a rule that omits a syntax element indicating the number of explicitly provided slice row heights from the bitstream if the height of the video picture is equal to or less than the dimensions of a codec treeblock.

[0010] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with a rule that omits one or more syntax elements indicating the column widths of the one or more slices from the bitstream if the number of explicitly provided slice column widths is equal to the picture width in units of codec treeblocks.

[0011] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with a rule that omits one or more syntax elements indicating row heights of the one or more slices from the bitstream if the number of explicitly provided slice row heights is equal to the picture height in units of codec tree blocks.

[0012] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with a rule that specifies that slice segmentation information be included in the bitstream.

[0013] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video slice including one or more rectangular slices and a video bitstream according to a rule. The rule specifies determining uniform slice heights based on a first syntax element and a second syntax element, wherein the first syntax element specifies the height of the rectangular slices in units of codec tree unit rows in the video slice and the second syntax element specifies the number of explicitly provided slice heights in the video slice.

[0014] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video picture including one or more slices and a video bitstream according to a rule. The rule specifies that a syntax element is equal to or greater than a uniform slice column or uniform slice row dimension. The syntax element indicates a dimension in units of a codec tree block, excluding a total dimension of multiple explicitly provided slice column widths or multiple explicitly provided slice row heights.

[0015] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video slice including one or more slices and a video bitstream according to a rule. The rule specifies that a syntax element is equal to or greater than a uniform slice height. The syntax element indicates a height in units of codec tree blocks, excluding a total height of multiple explicitly provided slice heights.

[0016] In another example aspect, a video processing method is disclosed. The method includes performing conversion between a video and a bitstream of the video according to a rule. The rule specifies using a syntax element for the conversion to indicate a maximum number of affine merge candidates allowed in a sub-block-based merge candidate list.

[0017] In another example aspect, a video processing method is disclosed. The method includes performing a conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures, each sub-picture comprising one or more slices, wherein the codec representation conforms to a format rule; wherein the format rule provides for deriving a picture-level slice index for each slice in each sub-picture in the video picture when rectangular slice mode is enabled, without explicit signaling in the codec representation; wherein the format rule provides for a number of codec tree units in each slice to be derived from the picture-level slice index.

[0018] In another example aspect, another video processing method is disclosed. The method includes performing a conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures, the sub-pictures comprising one or more slices, wherein the codec representation conforms to a format rule, wherein the format rule provides that a sub-picture-level slice index can be derived based on information in the codec representation without signaling the sub-picture-level slice index in the codec representation.

[0019] In another example aspect, another video processing method is disclosed. The method includes performing a conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures and / or one or more slices, wherein the codec representation complies with a format rule, and wherein the conversion complies with a constraint rule.

[0020] In another example aspect, another video processing method is disclosed. The method includes performing conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more slices and / or one or more slices; wherein the codec representation conforms to a format rule; wherein the format rule specifies that a field at the video picture level carries information about segmentation of the slices and / or slices in the video picture.

[0021] In another example aspect, another video processing method is disclosed that includes performing a conversion between a video comprising one or more pictures and a codec representation of the video, wherein the conversion complies with a segmentation rule that determines whether rectangular segmentation is used to segment the video pictures and a minimum number of slices into which the video pictures are segmented.

[0022] In another example aspect, another video processing method is disclosed. The method includes performing conversion between a video slice of a video region of a video and a codec representation of the video, wherein the codec representation conforms to a format rule, wherein the format rule provides that the codec representation signals the video slice based on a top left position of the video slice, wherein the format rule provides that the codec representation signals a height and / or a width of the video slice in segmentation information, wherein the segmentation information is signaled at a video unit level.

[0023] In another example aspect, another video processing method is disclosed. The method includes performing a conversion between a video including video pictures and a codec representation of the video, wherein the codec representation conforms to a format rule, wherein the format rule provides for omitting signaling a difference between a slice index of a first slice in a rectangular slice and a slice index of a first slice in a next rectangular slice.

[0024] In another example aspect, another video processing method is disclosed. The method includes performing conversion between a video and a codec representation of the video, wherein the codec representation conforms to a format rule, wherein the format rule specifies a relationship between a width of a video picture and a size of a codec tree unit to control signaling of information used to derive a number of slice columns or a number of slice rows in the video picture.

[0025] In another example aspect, another video processing method is disclosed. The method includes performing conversion between a video comprising one or more video pictures and a codec representation of the video, wherein the codec representation conforms to a format rule, wherein the format rule specifies including slice layout information in the codec representation of the video pictures comprising evenly spaced slices and non-evenly spaced slices.

[0026] In yet another exemplary aspect, a video encoder apparatus is disclosed. The video encoder includes a processor configured to implement the above method.

[0027] In yet another exemplary aspect, a video decoder apparatus is disclosed. The video decoder includes a processor configured to implement the above method.

[0028] In yet another exemplary aspect, a computer-readable medium having stored thereon code is disclosed. The code is in the form of processor-executable code embodying one of the methods described herein.

[0029] These features and others are described throughout this document. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] Figure 1 An example of raster scan stripe partitioning of a picture is shown, where the picture is divided into 12 slices and 3 raster scan stripes.

[0031] Figure 2 An example of rectangular strip partitioning of a picture is shown, where the picture is divided into 24 slices (6 slice columns and 4 slice rows) and 9 rectangular strips.

[0032] Figure 3 An example of partitioning a picture into slices and rectangular strips is shown, where the picture is divided into 4 slices (2 slice columns and 2 slice rows) and 4 rectangular strips.

[0033] Figure 4 It shows that the picture is partitioned into 18 slices, 24 slices and 24 sub-pictures.

[0034] Figure 5 The nominal vertical and horizontal positions of the 4:2:2 luma and chroma samples in the picture are shown.

[0035] Figure 6 An example of picture partitioning is shown. Solid lines 602 represent slice boundaries; dashed lines 604 represent stripe boundaries, and dashed lines 606 represent sub-picture boundaries. The figure indicates the picture-level index, decoding order index, sub-picture-level index, sub-picture index, and slice index of the four slices.

[0036] Figure 7 is a block diagram of an example video processing system.

[0037] Figure 8 It is a block diagram of a video processing device.

[0038] Figure 9 is a flow chart of an example method of video processing.

[0039] Figure 10 is a block diagram illustrating a video encoding and decoding system according to some embodiments of the present disclosure.

[0040] Figure 11 is a block diagram illustrating an encoder according to some embodiments of the present disclosure.

[0041] Figure 12 is a block diagram illustrating a decoder according to some embodiments of the present disclosure.

[0042] Figure 13 is a flowchart representation of a method for video processing according to the present technology.

[0043] Figure 14is a flowchart representation of another method for video processing according to the present technology.

[0044] Figure 15 is a flowchart representation of another method for video processing according to the present technology.

[0045] Figure 16 is a flowchart representation of another method for video processing according to the present technology.

[0046] Figure 17 is a flowchart representation of another method for video processing according to the present technology.

[0047] Figure 18 is a flowchart representation of another method for video processing according to the present technology.

[0048] Figure 19 is a flowchart representation of another method for video processing according to the present technology.

[0049] Figure 20 is a flowchart representation of another method for video processing according to the present technology.

[0050] Figure 21 is a flowchart representation of another method for video processing according to the present technology.

[0051] Figure 22 is a flowchart representation of another method for video processing according to the present technology.

[0052] Figure 23 is a flowchart representation of yet another method for video processing according to the present technology. DETAILED DESCRIPTION

[0053] The section headings used in this document are intended to facilitate understanding and do not limit the application of the techniques and embodiments disclosed in each section to that section. Furthermore, the use of H.266 terminology in some descriptions is intended to facilitate understanding and is not intended to limit the scope of the disclosed techniques. Thus, the techniques described herein are also applicable to other video codec protocols and designs.

[0054] 1. Overview

[0055] This document relates to video codec technology. Specifically, it is about the signaling of sub-pictures, slices, and slices. These ideas can be applied alone or in various combinations to any video codec standard or non-standard video codec that supports multi-layer video coding, such as the Versatile Video Codec (VVC) under development.

[0056] 2. Abbreviation

[0057] APS Adaptive Parameter Set

[0058] AU Access Unit

[0059] AUD Access Unit Delimiter

[0060] AVC Advanced Video Codec

[0061] CLVS codec layer video sequence

[0062] CPB Codec Picture Buffer

[0063] CRA Clean Random Access

[0064] CTU Codec Tree Unit

[0065] CVS codec video sequence

[0066] DPB decoded picture buffer

[0067] DPS decoding parameter set

[0068] EOB End of bitstream

[0069] EOS sequence end

[0070] GDR Gradual Decode Refresh

[0071] HEVC High-Efficiency Video Codec

[0072] HRD Hypothesized Reference Decoder

[0073] IDR Instant Decode Refresh

[0074] JEM Joint Exploration Model

[0075] MCTS motion-constrained patches

[0076] NAL Network Abstraction Layer

[0077] OLS output layer set

[0078] PH Image Header

[0079] PPS Picture Parameter Set

[0080] PTL grades, tiers, and levels

[0081] PU picture unit

[0082] RBSP Raw Byte Sequence Payload

[0083] SEI Supplemental Enhancement Information

[0084] SPS sequence parameter set

[0085] SVC Scalable Video Codec

[0086] VCL video codec layer

[0087] VPS Video Parameter Set

[0088] VTM VVC test model

[0089] VUI Video Availability Information

[0090] VVC multifunctional video codec

[0091] 3. Introduction to Video Codec

[0092] Video codec standards have primarily evolved through the development of the renowned ITU-T and ISO / IEC standards. ITU-T produced H.261 and H.263, while ISO / IEC produced MPEG-1 and MPEG-4 Visual. The two organizations jointly produced the H.262 / MPEG-2 Video standard, the H.264 / MPEG-4 Advanced Video Coding (AVC) standard, and the H.265 / HEVC standard. Since H.262, video codec standards have been based on a hybrid video codec architecture that utilizes temporal prediction plus transform coding. To explore future video codec technologies beyond HEVC, VCEG and MPEG jointly established the Joint Video Exploration Team (JVET) in 2015. Since then, many new approaches have been adopted by JVET and incorporated into reference software called the Joint Exploration Model (JEM). JVET meetings are held quarterly, and the goal for new codec standards is to reduce bitrates by 50% compared to HEVC. At the JVET meeting in April 2018, the new video codec standard was officially named Versatile Video Coding (VVC), and the first version of the VVC Test Model (VTM) was released. As efforts continue to advance VVC standardization, new codec technologies are adopted for the VCC standard at each JVET meeting. The VVC working draft and test model (VTM) are then updated after each meeting. The VVC project's current goal is to achieve technical completion (FDIS) at the July 2020 meeting.

[0093] 3.1. Image Segmentation Scheme in HEVC

[0094] HEVC includes four different picture partitioning schemes, namely normal slice, dependent slice, slice and Wavefront Parallel Processing (WPP), which can be used for Maximum Transfer Unit (MTU) size matching, parallel processing and reduced end-to-end delay.

[0095] Regular slices are similar to those in H.264 / AVC. Each regular slice is encapsulated in its own NAL unit, and intra-picture prediction (intra sample prediction, motion information prediction, codec mode prediction) and entropy codec dependencies are disabled across slice boundaries. Therefore, regular slices can be reconstructed independently of other regular slices in the same picture (although there may still be interdependencies due to loop filtering operations).

[0096] Regular slices are the only tool available for parallelization, and are also available in H.264 / AVC in a nearly identical form. Regular slice-based parallelization does not require much inter-processor or inter-core communication (except for inter-processor or inter-core data sharing for motion compensation when decoding predictive codec pictures, which is generally much more significant due to intra-picture prediction). However, for the same reasons, the use of regular slices incurs significant codec overhead due to the bit cost of the slice header and the lack of prediction across slice boundaries. Furthermore, due to the intra-picture independence of regular slices and the fact that each regular slice is encapsulated in its own NAL unit, regular slices (compared to the other tools mentioned below) also serve as a key mechanism for bitstream segmentation to match MTU size requirements. In many cases, the goals of parallelization and MTU size matching place conflicting demands on the layout of slices within a picture. Recognition of this situation led to the development of the parallelization tools mentioned below.

[0097] Dependent slices have short headers and allow the bitstream to be split at treeblock boundaries without breaking any intra-picture prediction. Basically, dependent slices provide for partitioning a regular slice into multiple NAL units to provide reduced end-to-end latency by allowing part of a regular slice to be sent before coding of the entire regular slice is complete.

[0098] In WPP, a picture is partitioned into individual codec tree block (CTB) rows. Entropy decoding and prediction are allowed to use data from CTBs in other partitions. Parallel processing is possible through parallel decoding of CTB rows, where the start of decoding is delayed by two CTBs, ensuring that data related to the CTBs above and to the right of the target CTB is available before the target CTB is decoded. This staggered start (which, when represented graphically, looks like a wavefront) allows parallelization to utilize as many processors / cores as the picture contains CTB rows. Because intra-picture prediction is allowed between adjacent tree block rows within a picture, the inter-processor / inter-core communication required to implement intra-picture prediction can be substantial. WPP partitioning does not result in the generation of additional NAL units compared to when it is not used, so WPP is not a tool for MTU size matching. However, if MTU size matching is required, regular slices can be used with WPP, but with some codec overhead.

[0099] Slices define the horizontal and vertical boundaries that divide an image into slice columns and slice rows. Slice columns extend from the top to the bottom of the image. Similarly, slice rows extend from the left to the right of the image. The number of slices in an image can be simply derived by multiplying the number of slice columns by the number of slice rows.

[0100] Before decoding the top left CTB of the next slice in the order of the slice raster scan of the picture, the scan order of the CTBs is changed to be local within the slice (in the order of the slice's CTB raster scan). Similar to regular slices, slices break intra-picture prediction dependencies and entropy decoding dependencies. However, they do not need to be included in a single NAL unit (the same as WPP in this respect); therefore, slices cannot be used for MTU size matching. Each slice can be processed by one processor / core, and the inter-processor / inter-core communication required for intra-picture prediction between processing units decoding adjacent slices is limited to transmitting a shared slice header when a slice spans more than one slice, and sharing of reconstruction samples and metadata related to loop filtering. When more than one slice or WPP segment is included in a slice, the entry point byte offset of each slice or WPP segment in the slice except the first slice is signaled in the slice header.

[0101] For simplicity, HEVC has specified restrictions on the application of four different picture partitioning schemes. A given codec video sequence cannot include both slices and wavefronts from most profiles specified in the HEVC standard. For each slice and slice, one or both of the following conditions must be met: 1) all codec treeblocks in a slice belong to the same slice; 2) all codec treeblocks in a slice belong to the same slice. Finally, a wavefront segment contains exactly one CTB row. When using WPP, if a slice starts on a CTB row, it must end on the same CTB row.

[0102] The latest revision to HEVC is specified in the JCT-VC output document JCTVC-AC1005, J. Boyce, A. Ramasubramonian, R. Skupin, G.J. Sullivan, A. Tourapis, Y.-K. Wang (eds.), "HEVC Additional Supplemental Enhancement Information (Draft 4)", publicly released on October 24, 2017: http: / / phenix.int-evry.fr / jct / doc_end_user / documents / 29_Macau / wg11 / JCTVC-AC1005-v2.zip. With the inclusion of this revision, HEVC specifies three types of MCTS-related SEI (Supplemental Enhancement Information) messages: the time-domain MCTS SEI message, the MCTS Extraction Information Set SEI message, and the MCTS Extraction Information Nesting SEI message.

[0103] The temporal MCTS SEI message indicates the presence of MCTS in the bitstream and signals the MCTS. For each MCTS, motion vectors are restricted to pointing to full sample positions within the MCTS and fractional sample positions that only require full sample positions within the MCTS for interpolation, and motion vector candidates derived from blocks outside the MCTS for temporal motion vector prediction are not allowed. In this way, each MCTS can be decoded independently without the presence of slices not included in the MCTS.

[0104] The MCTS extraction information set SEI message provides supplementary information (defined as part of the semantics of the SEI message) that can be used in MCTS sub-bitstream extraction to generate a bitstream that conforms to the MCTS set. The information consists of multiple extraction information sets, each of which defines multiple MCTS sets and contains RBSP bytes that replace the VPS, SPS, and PPS to be used in the MCTS sub-bitstream extraction process. When extracting a sub-bitstream according to the MCTS sub-bitstream extraction process, the parameter sets (VPS, SPS, and PPS) need to be rewritten or replaced because one or all slice address-related syntax elements (including first_slice_segment_in_pic_flag and slice_segment_address) usually need to have different values, so the slice header needs to be slightly updated.

[0105] 3.2. Image Segmentation in VVC

[0106] In VVC, a picture is divided into one or more slice rows and one or more slice columns. A slice is a sequence of CTUs covering a rectangular area of ​​a picture. The CTUs in a slice are scanned in raster scan order within the slice.

[0107] A slice consists of an integer number of complete slices or an integer number of consecutive complete CTU rows within a slice of a picture.

[0108] Two striping modes are supported: raster scan striping mode and rectangular striping mode. In raster scan striping mode, a strip contains a sequence of complete slices in a slice raster scan of a picture. In rectangular striping mode, a strip contains multiple complete slices that together form a rectangular area of ​​the picture, or multiple consecutive complete CTU rows that together form a slice of a rectangular area of ​​the picture. The slices within a rectangular stripe are scanned in slice raster scan order within the rectangular area corresponding to the stripe.

[0109] A sub-picture consists of one or more strips that together cover a rectangular area of ​​the picture.

[0110] Figure 1 An example of raster scan stripe partitioning of a picture is shown, where the picture is divided into 12 slices and 3 raster scan stripes.

[0111] Figure 2 An example of rectangular strip partitioning of a picture is shown, where the picture is divided into 24 slices (6 slice columns and 4 slice rows) and 9 rectangular strips.

[0112] Figure 3 An example of a picture being divided into slices and rectangular strips is shown, where the picture is divided into 4 slices (2 slice columns and 2 slice rows) and 4 rectangular strips.

[0113] Figure 4 An example of sub-picture partitioning of a picture is shown, where the picture is divided into 18 slices, with the 12 slices on the left hand side each covering a 4×4 CTU strip, and the 6 slices on the right hand side each covering two vertically stacked strips of 2×2 CTUs, resulting in a total of 24 slices and 24 sub-pictures of different dimensions (each slice is a sub-picture).

[0114] 3.3. Signaling of SPS / PPS / Picture Header / Slice Header in VVC

[0115] 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0116]

[0117]

[0118]

[0119]

[0120]

[0121]

[0122]

[0123] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0124]

[0125]

[0126]

[0127]

[0128] 7.3.2.7 Picture header structure syntax

[0129]

[0130]

[0131]

[0132]

[0133]

[0134]

[0135] 7.3.7.1 General Strip Header Syntax

[0136]

[0137]

[0138]

[0139] 3.4. Example Specifications for Slices, Stripes, and Sub-Pictures

[0140] 3 Definition

[0141] Picture level slice index: When rect_slice_flag is equal to 1, the slice index of the slice list in the picture (in the order they are signaled in the PPS).

[0142] Sub-picture level slice index: When rect_slice_flag is equal to 1, the slice index of the slice list in the sub-picture (in the order they are signaled in the PPS).

[0143] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Picture Scanning Process

[0144] The variable NumTileColumns that specifies the number of tile columns and the list colWidth[i] that specifies the width of the i-th tile column in CTB units (where i ranges from 0 to NumTileColumn-1, inclusive) are derived as follows:

[0145]

[0146] The variable numtierrows that specifies the number of tile rows and the list RowHeight[j] that specifies the height of the j-th tile row in CTB units (where j ranges from 0 to NumTileRows-1, inclusive) are derived as follows:

[0147]

[0148]

[0149] The variable NumTilesInPic is set equal to NumTileColumns*NumTileRows.

[0150] The list tileColBd[i] that specifies the position of the i-th tile column boundary in CTB units (where i ranges from 0 to NumTileColumns, inclusive) is derived as follows:

[0151] for(tileColBd[0]=0,i=0;i <NumTileColumns;i++)

[0152] tileColBd[i+1]=tileColBd[i]+colWidth[i] (25)

[0153] NOTE 1 – The size of the array tileColBd[] is one greater than the actual number of tile columns in the derivation of CtbToTileColBd[].

[0154] The list tileRowBd[j] that specifies the position of the jth tile row boundary in CTB units (where j ranges from 0 to NumTileRows, inclusive) is derived as follows:

[0155] for(tileRowBd[0]=0,j=0;j <NumTileRows;j++)

[0156] tileRowBd[j+1]=tileRowBd[j]+RowHeight[j] (26)

[0157] NOTE 2 – The size of the array tileRowBd[] in the above derivation is one larger than the actual number of tile rows in the derivation of CtbToTileRowBd[].

[0158] The list CtbToTileColBd[ctbAddrX] that specifies the conversion from horizontal CTB addresses to left tile column boundaries in units of CTBs (where ctbAddrX ranges from 0 to PicWidthInCtbsY, inclusive) is derived as follows:

[0159]

[0160] NOTE 3 – The size of the array CtbToTileColBd[] in the above derivation is one greater than the actual number of picture widths in the CTB signaled in the derived slice_data().

[0161] The list CtbToTileRowBd[ctbAddrY] that specifies the conversion from the vertical CTB address to the top tile column boundary in units of CTB (where ctbAddrY ranges from 0 to PicHeightInCtbsY, inclusive) is derived as follows:

[0162]

[0163]

[0164] NOTE 4 – The size of the array CtbToTileRowBd[] in the above derivation is one greater than the actual number of picture heights in the CTB signaled in slice_data().

[0165] For rectangular slices, the list NumCtusInSlice[i] specifying the number of CTUs in the i-th slice (where i ranges from 0 to num_slices_in_pic_minus1, inclusive), the list SliceTopLeftTileIdx[i] specifying the index of the top left slice of the slice (where i ranges from 0 to num_slices_in_pic_minus1, inclusive), and the matrix CtbAddrInSlice[i][j] specifying the picture raster scan address of the j-th CTB within the i-th slice (where i ranges from 0 to num_slices_in_pic_minus1, inclusive) are derived as follows:

[0166]

[0167]

[0168] Among them, the function AddCtbsToSlice(sliceIdx, startX, stopX, startY, stopY) is defined as follows:

[0169]

[0170] It is a requirement of bitstream conformance that the value of NumCtusInSlice[i], where i ranges from 0 to num_slices_in_pic_minus1, inclusive, shall be greater than 0. Furthermore, it is a requirement of bitstream conformance that the matrix CtbAddrInSlice[i][j], where i ranges from 0 to num_slices_in_pic_minus1, inclusive, and j ranges from 0 to NumCtusInSlice[i]-1, inclusive, shall include all CTB addresses in the range from 0 to PicSizeInCtbsY-1 once and only once.

[0171] The list CtbToSubpicIdx[ctbAddrRs] that specifies the conversion from CTB addresses in the picture raster scan to sub-picture indices (where tbAddrRs ranges from 0 to PicSizeInCtbsY-1, inclusive) is derived as follows:

[0172]

[0173] The list NumSlicesInSubpic[i] that specifies the number of rectangular slices in the i-th sub-picture is derived as follows:

[0174]

[0175]

[0176] 7.3.4.3 Picture Parameter Set RBSP Semantics

[0177] subpic_id_mapping_in_pps_flag equal to 1 specifies that sub-picture ID mapping is signaled in the PPS. subpic_id_mapping_in_pps_flag equal to 0 specifies that sub-picture ID mapping is not signaled in the PPS. If subpic_id_mapping_explicitly_signaled_flag is 0 or subpic_id_mapping_in_sps_flag is 1, then the value of subpic_id_mapping_in_pps_flag shall be 0. Otherwise (subpic_id_mapping_explicitly_signaled_flag is 1 and subpic_id_mapping_in_sps_flag is 0), the value of subpic_id_mapping_in_pps_flag shall be 1.

[0178] pps_num_subpics_minus1 shall be equal to sps_num_subpics_minus1.

[0179] pps_subpic_id_len_minus1 shall be equal to sps_subpic_id_len_minus1.

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

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

[0182]

[0183] A requirement for bitstream conformance is that the following two constraints apply:

[0184] – For any two different values ​​of i and j in the range 0 to sps_num_subpics_minus1 (inclusive), SubpicIdVal[i] shall not be equal to SubpicIdVal[j].

[0185] – When the current picture is not the first picture of the CLVS, for each value of i in the range 0 to sps_num_subpics_minus1 (inclusive), if the value of SubpicIdVal[i] is not equal to the value of SubpicIdVal[i] of the previous picture in decoding order in the same layer, the nal_unit_type of all codec slice NAL units of the sub-picture in the current picture with sub-picture index i shall be equal to the specified value in the range IDR_W_RADL to CRA_NUT (inclusive).

[0186] no_pic_partition_flag equal to 1 specifies that no picture partitioning is applied to each picture of the referenced PPS. no_pic_partition_flag equal to 0 specifies that each picture of the referenced PPS may be partitioned into more than one slice or slice.

[0187] One requirement for bitstream conformance is that the value of no_pic_partition_flag shall be the same for all PPSs referenced by a codec picture within a CLVS.

[0188] It is a bitstream conformance requirement that when the value of sps_num_subpics_minus1+1 is greater than 1, the value of no_pic_partition_flag shall not be equal to 1.

[0189] pps_log2_ctu_size_minus5 plus 5 specifies the luma codec treeblock size for each CTU. pps_log2_ctu_size_minus5 shall be equal to sps_log2_ctu_size_minus5.

[0190] num_exp_tile_columns_minus1 plus 1 specifies the number of explicitly provided tile column widths. The value of num_exp_tile_columns_minus1 shall be in the range of 0 to PicWidthInCtbsY-1, inclusive. When no_pic_partition_flag is equal to 1, the value of num_exp_tile_columns_minus1 is inferred to be equal to 0.

[0191] num_exp_tile_rows_minus1 plus 1 specifies the number of explicitly provided tile row heights. The value of num_exp_tile_rows_minus1 shall 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.

[0192] tile_column_width_minus1[i] plus 1 specifies the width of the i-th tile column in CTBs, where i ranges 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 with indices 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] shall be in the range of 0 to PicWidthInCtbsY-1 (inclusive). When not present, the value of tile_column_width_minus1[0] is inferred to be equal to PicWidthInCtbsY-1.

[0193] tile_row_height_minus1[i] plus 1 specifies the height of the i-th slice row in CTBs, where i ranges 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 with indices 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] shall be in the range of 0 to PicHeightInCtbsY-1 (inclusive). When not present, the value of tile_row_height_minus1[0] is inferred to be equal to PicHeightInCtbsY-1.

[0194] rect_slice_flag equal to 0 specifies that the slices within each slice are in raster scan order and that slice information is not signaled in the PPS. rect_slice_flag equal to 1 specifies that the slices within each slice cover a rectangular area of ​​the picture and that slice information is signaled in the PPS. When not present, 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 shall be equal to 1.

[0195] single_slice_per_subpic_flag equal to 1 specifies that each sub-picture consists of one and only one rectangular slice. single_slice_per_subpic_flag equal to 0 specifies that each sub-picture may consist of one or more rectangular slices. When single_slice_per_subpic_flag is equal to 1, num_slices_in_pic_minus1 is inferred to be equal to sps_num_subpics_minus1. When not present, the value of single_slice_per_subpic_flag is inferred to be equal to 0.

[0196] num_slices_in_pic_minus1 plus 1 specifies the number of rectangular slices in each picture referencing the PPS. The value of num_slices_in_pic_minus1 shall be in the range of 0 to MaxSlicesPerPicture1, inclusive, where MaxSlicesPerPicture is specified in Annex A. When no_pic_partition_flag is equal to 1, the value of num_slices_in_pic_minus1 is inferred to be equal to 0.

[0197] tile_idx_delta_present_flag equal to 0 specifies that tile_idx_delta values ​​are not present in the PPS, and all rectangular slices in pictures referencing the PPS are specified in raster order according to the process defined in clause 6.5.1. tile_idx_delta_present_flag equal to 1 specifies that tile_idx_delta values ​​may be present in the PPS, and all rectangular slices in pictures referencing the PPS are specified in the order indicated by the tile_idx_delta values. When not present, the value of tile_idx_delta_present_flag is inferred to be equal to 0.

[0198] slice_width_in_tiles_minus1[i] plus 1 specifies the width of the i-th rectangular strip in tile columns. The value of slice_width_in_tiles_minus1[i] should be in the range of 0 to NumTileColumns-1 (inclusive).

[0199] When slice_width_in_tiles_minus1[i] is not present, the following applies:

[0200] – If NumTileColumns is equal to 1, the value of slice_width_in_tiles_minus1[i] is inferred to be equal to 0.

[0201] – Otherwise, the value of slice_width_in_tiles_minus1[i] is inferred as specified in clause 6.5.1.

[0202] slice_height_in_tiles_minus1[i] plus 1 specifies the height of the i-th rectangular slice in tile rows. The value of slice_height_in_tiles_minus1[i] should be in the range of 0 to NumTileRows-1 (inclusive).

[0203] When slice_height_in_tiles_minus1[i] is not present, the following applies:

[0204] – If NumTileRows is equal to 1, or tile_idx_delta_present_flag is equal to 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.

[0205] – 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].

[0206] num_exp_slices_in_tile[i] specifies the number of slice heights explicitly provided in the current slice that contains more than one rectangular strip. The value of num_exp_slices_in_tile[i] shall be in the range of 0 to RowHeight[tileY]-1, inclusive, where tileY is the index of the slice row containing the i-th strip. When not present, 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 inferred to be equal to 1.

[0207] exp_slice_height_in_ctus_minus1[j] plus 1 specifies the height of the j-th rectangular slice in the current slice in CTU rows. The value of exp_slice_height_in_ctus_minus1[j] shall be in the range of 0 to RowHeight[tileY]-1 (inclusive), where tileY is the slice row index of the current slice.

[0208] When num_exp_slices_in_tile[i] is greater than 0, the variables NumSlicesInTile[i] and SliceHeightInCtusMinus1[i+k] with k in the range of 0 to NumSlicesInTile[i]-1 are derived as follows:

[0209]

[0210] tile_idx_delta[i] specifies the difference between the tile index of the first tile in the i-th rectangular stripe and the tile index of the first tile in the i+1-th rectangular stripe. The value of tile_idx_delta[i] shall be in the range -NumTilesInPic+1 to NumTilesInPic-1, inclusive. When not present, the value of tile_idx_delta[i] is inferred to be equal to 0. When present, the value of tile_idx_delta[i] shall not be equal to 0.

[0211] …

[0212] 7.4.2.4.5 Order of VCL NAL units and their association with coded and decoded pictures

[0213] The order of VCL NAL units within a codec picture is constrained as follows:

[0214] – For any two codec slice NAL units A and B of a codec picture, let subpicIdxA and subpicIdxB be their sub-picture level index values, and sliceAddrA and sliceddrB be their slice_address values.

[0215] – Codec slice NAL unit A shall precede codec slice NAL unit B when any of the following conditions is true:

[0216] –subpicIdxA is less than subpicIdxB.

[0217] –subpicIdxA is equal to subpicIdxB, and sliceAddrA is less than sliceAddrB.

[0218] 7.4.8.1 Common Strip Header Semantics

[0219] The variable CuQpDeltaVal, which specifies the difference between the luma quantization parameter and its prediction for a codec containing cu_qp_delta_abs, is set equal to 0. The variable CuQpDeltaVal specifies the difference between the luma quantization parameter and its prediction for a codec containing cu_chroma_qp_offset_flag. Cr and Qp′ CbCr The value of the variable CuQpOffset to use when the corresponding value of the quantization parameter Cb 、CuQpOffset Cr and CuQpOffset CbCr are all set equal to 0.

[0220] picture_header_in_slice_header_flag equal to 1 specifies that the PH syntax structure is present in the slice header.

[0221] picture_header_in_slice_header_flag equal to 0 specifies that the PH syntax structure is not present in the slice header.

[0222] One requirement for bitstream conformance is that the value of picture_header_in_slice_header_flag shall be the same in all codec slices of CLVS.

[0223] When picture_header_in_slice_header_flag is equal to 1 for a coded slice, one requirement for bitstream conformance is that VCL NAL units with nal_unit_type equal to PH_NUT shall not appear in the CLVS.

[0224] When picture_header_in_slice_header_flag is equal to 0, all coded slices in the current picture shall have picture_header_in_slice_header_flag equal to 0, and the current PU shall have a PH NAL unit.

[0225] slice_subpic_id specifies the sub-picture ID of the sub-picture containing the slice. If slice_subpic_id exists, the value of the variable CurrSubpicIdx is derived such that SubpicIdVal[CurrSubpicIdx] is equal to slice_subpic_id. Otherwise (slice_subpic_id does not exist), CurrSubpicIdx is derived to be 0. The length of slice_subpic_id is sps_subpic_id_len_minus1+1 bits.

[0226] slice_address specifies the slice address of the slice. When not present, the value of slice_address is inferred to be equal to 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 equal to 0.

[0227] If rect_slice_flag is equal to 0, the following applies:

[0228] - The strip address is the raster scan slice index.

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

[0230] -slice_address values ​​should be in the range of 0 to NumTilesInPic1-1 (inclusive).

[0231] Otherwise (rect_slice_flag is equal to 1), the following applies:

[0232] - The slice address is the sub-picture level slice index of the slice.

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

[0234] -slice_address values ​​should be in the range of 0 to NumSlicesInSubpic[CurrSubpicIdx]-1 (inclusive).

[0235] A requirement for bitstream conformance is that the following constraints apply:

[0236] - If rect_slice_flag is equal to 0 or subpic_info_present_flag is equal to 0, the value of slice_address shall not be equal to the value of slice_address of any other codec slice NAL unit of the same codec picture.

[0237] Otherwise, the pair of slice_subpic_id value and slice_address value shall not be equal to the pair of slice_subpic_id value and slice_address value of any other codec slice NAL unit of the same codec picture.

[0238] - The shape of the slices of a picture shall be such that, when decoded, the entire left boundary and the entire top boundary of each CTU shall consist of the picture boundary or of the boundary of the previously decoded CTU(s).

[0239] sh_extra_bit[i] may be equal to 1 or 0. Decoders conforming to this version of this specification shall ignore the value of sh_extra_bit[i]. Its value shall not affect the conformance of the decoder to the profile specified in this version of the specification.

[0240] num_tiles_in_slice_minus1 plus 1 (when present) specifies the number of tiles in a slice. The value of num_tiles_in_slice_minus1 should be in the range of 0 to NumTilesInPic-1 (inclusive).

[0241] The variable NumCtusInCurrSlice specifies the number of CTUs in the current slice, and the list of picture raster scan addresses CtbAddrInCurrSlice[i] (where i ranges from 0 to NumCtusInCurrSlice-1 (inclusive)) for the i-th CTB in the slice is derived as follows:

[0242]

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

[0244]

[0245]

[0246] 3.5. Color Space and Chroma Subsampling

[0247] A color space, also called a color model (or color system), is an abstract mathematical model that simply describes the range of colors as a tuple of numbers, usually 3 or 4 values ​​or color components (such as RGB). Fundamentally, a color space is a elaboration of coordinate systems and subspaces.

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

[0249] YCbCr, Y'CbCr, or Y Pb / Cb Pr / Cr (also written as YCBCR or Y'CBCR) is a family of colorspaces used as part of the color image pipeline in video and digital photography systems. Y' is the luma component, and CB and CR are the blue-difference and red-difference chroma components. Y' (with a prime) is distinguished from Y (Y is luma), which means that the light intensity is nonlinearly encoded based on the gamma-corrected RGB primaries.

[0250] Chroma subsampling is the practice of encoding an image at a lower resolution for chroma information than for luminance information by exploiting the fact that the human visual system is less sensitive to color differences than to luminance. 3.5.1. 4:4:4

[0252] Each of the three Y'CbCr components has the same sampling rate, so there is no chroma subsampling. This scheme is sometimes used in high-end film scanners and film post-production. 3.5.2. 4:2:2

[0254] The two chroma components are sampled at half the luma sampling rate: the horizontal chroma resolution is halved, while the vertical chroma resolution remains unchanged. This reduces the bandwidth of the uncompressed video signal by one third, but there is almost no visual difference. Figure 5 Examples of nominal vertical position and nominal horizontal position for a 4:2:2 color format are depicted in . 3.5.3. 4:2:0

[0256] Compared to 4:1:1, horizontal sampling in 4:2:0 is doubled, but vertical resolution is halved because the Cb and Cr channels are sampled only on alternate lines in this scheme. Therefore, the data rate remains the same. Both Cb and Cr are subsampled by a factor of 2 both horizontally and vertically. There are three variants of the 4:2:0 scheme, with different horizontal and vertical positions.

[0257] In MPEG-2, Cb and Cr coexist horizontally. Cb and Cr are located between pixels in the vertical direction (in the gap).

[0258] In JPEG / JFIF, H.261, and MPEG-1, Cb and Cr are located midway between alternate luma samples.

[0259] In 4:2:0 DV, Cb and Cr are co-sited horizontally and vertically on alternate lines.

[0260] Table 3-1. SubWidthC and SubHeightC values ​​derived from chroma_format_idc and separate_colour_plane_flag

[0261]

[0262] 4. Examples of technical problems solved by the disclosed embodiments

[0263] The existing design of SPS / PPS / picture header / slice header signaling in VVC has the following problems:

[0264] 1) According to the current VVC text, when rect_slice_flag is equal to 1, the following applies:

[0265] a.slice_address represents the sub-picture level slice index of the slice.

[0266] b. The sub-picture level slice index is defined as the slice index of the slice list in the sub-picture (in the order they are signaled in the PPS).

[0267] c. Picture level slice index is defined as the slice index of the slice list in the picture (in the order they are signaled in the PPS).

[0268] d. For any two slices belonging to two different sub-pictures, the slice associated with the smaller sub-picture index comes earlier in the decoding order, while for any two slices belonging to the same sub-picture, the slice with the smaller sub-picture level slice index comes earlier in the decoding order.

[0269] e. Assuming that the increasing order of the picture-level slice index values ​​is the same as the decoding order of the slices, the variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice is derived by equation 117 in the current VVC text.

[0270] However, when some stripes are generated by dividing a slice, some of the above aspects may be violated. Figure 6 In the example shown in , when a picture is divided into two slices by a vertical slice boundary, and each of the two slices is divided into two strips by the same horizontal boundary across the entire picture, the upper two strips are included in the first sub-picture, and the lower two strips are included in the second sub-picture. In this case, according to the current VVC text, the picture-level slice index values ​​of the four slices in slice raster scan order will be 0, 2, 1, 3, while the decoding order index values ​​of the four slices in slice raster scan order will be 0, 1, 2, 3. Therefore, the derivation of NumCtusInCurrSlice will be incorrect, and in turn the parsing of the slice data will be problematic, the decoded sample values ​​will be incorrect, and the decoder may crash.

[0271] 2) There are two types of slice signaling methods. In rectangular mode, all slice partitioning information is signaled in the PPS. In non-rectangular mode, partial slice partitioning information is signaled in the slice header. Therefore, in this mode, the complete slice division of the picture cannot be known until all slices of the picture are parsed.

[0272] 3) In rectangular mode, it is possible to arbitrarily signal the slices by setting tile_idx_delta. A bad bitstream may crash the decoder due to this mechanism.

[0273] 4) In some embodiments, when i is equal to num_slices_in_pic_minus1, tile_idx_delta[i] is not initialized.

[0274] 5) The merge estimation region (MER) size can be as small as 4 × 4. However, if the signaled MER size is smaller than the minimum CU size, it is meaningless.

[0275] 6) Note from the syntax table that the width of the 'num_exp_tile_columns_minus1'th tile column is presented in the syntax table as tile_column_width_minus1[num_exp_tile_columns_minus1]. However, semantically, tile_column_width_minus1[num_exp_tile_columns_minus1] is used to derive the width of tile columns with indices greater than or equal to num_exp_tile_columns_minus1 as specified in clause 6.5.1. In other words, the width of the 'num_exp_tile_columns_minus1'th tile column can be reset. Similar to the height of the 'num_exp_tile_columns_minus1'th tile row.

[0276] Figure 6 An example of picture partitioning is shown. Solid lines 602 represent slice boundaries; dashed lines 604 represent stripe boundaries, and dashed lines 606 represent sub-picture boundaries. The figure shows the picture-level index, decoding order index, sub-picture-level index, and sub-picture and slice indexes for four slices.

[0277] 5. Example Embodiments and Techniques

[0278] To address the above and other issues, the following methods are disclosed. The present invention should be viewed as an example of a general concept and should not be interpreted in a narrow sense. Furthermore, these inventions may be applied individually or in any combination.

[0279] 1. For slices in rectangular slice mode (ie, when rect_slice_flag is equal to 1), the picture-level slice index for each slice in each sub-picture is derived, and the derived value is used to derive the number of CTUs in each slice.

[0280] 2. Sub-picture level strip index can be defined / exported in the following ways:

[0281] a. In one example, the sub-picture level slice index is defined as "the slice index of the list of slices in the sub-picture (in their decoding order) when rect_slice_flag is equal to 1".

[0282] b. Optionally, the sub-picture level slice index is defined as "the slice index of the slice list in the sub-picture when rect_slice_flag is equal to 1, as specified by the variable SubpicLevelSliceIdx[i] derived in Equation 32 (as in Embodiment 1), where i is the picture level slice index of the slice."

[0283] c. In one example, a sub-picture index is derived for each slice with a specific value of the picture-level slice index.

[0284] d. In one example, a sub-picture level slice index is derived for each slice having a specific value of the picture level slice index.

[0285] e. In one example, when rect_slice_flag is equal to 1, the semantics of the slice address is specified as "the slice address is the sub-picture level slice index of the slice specified by the variable SubpicLevelSliceIdx[i] derived in Equation 32 (e.g., as in Embodiment 1), where i is the picture level slice index of the slice."

[0286] 3. The sub-picture level slice index of the slice is assigned to the slice in the first sub-picture containing the slice. The sub-picture level slice index of each slice can be stored in an array indexed by the picture level slice index (e.g., SubpicLevelSliceIdx[i] in embodiment 1).

[0287] a. In one example, the sub-picture level slice index is a non-negative integer.

[0288] b. In one example, the value of the sub-picture level slice index of the slice is greater than or equal to 0.

[0289] c. In one example, the value of the sub-picture level slice index of a slice is less than N, where N is the number of slices in the sub-picture.

[0290] d. In one example, if a first slice (slice A) and a second slice (slice B) are in the same sub-picture but they are different, the first sub-picture level slice index of the first slice (denoted as subIdxA) must be different from the second sub-picture level slice index of the second slice (denoted as subIdxB).

[0291] e. In one example, if a first sub-picture-level slice index (denoted as subIdxA) of a first slice (slice A) in a first sub-picture is less than a second sub-picture-level slice index (denoted as subIdxB) of a second slice (slice B) in the same first sub-picture, then IdxA is less than IdxB, where idxA and idxB represent slice indexes (also referred to as picture-level slice indices, e.g., sliceIdx) of slice A and slice B, respectively, in the entire picture.

[0292] f. In one example, if the first sub-picture level slice index (denoted as subIdxA) of a first slice (slice A) in a first sub-picture is less than the second sub-picture level slice index (denoted as subIdxB) of a second slice (slice B) in the same first sub-picture, then slice A precedes slice B in decoding order.

[0293] g. In one example, the sub-picture level slice index in a sub-picture is derived based on the picture level slice index (eg, sliceIdx).

[0294] 4. It is proposed to derive a mapping function / mapping table between the sub-picture level strip index and the picture level strip index in the sub-picture.

[0295] a. In one example, a two-dimensional array PicLevelSliceIdx[subPicIdx][SubPicLevelSliceIdx] is derived to map sub-picture level slice indices in a sub-picture to picture level slice indices, where PicLevelSliceIdx represents the picture level slice index of the slice, subPicIdx represents the index of the sub-picture, and SubPicLevelSliceIdx represents the sub-picture level slice index of the slice in the sub-picture.

[0296] i. In one example, the array NumSlicesInSubpic[subPicIdx] is used to derive PicLevelSliceIdx, where NumSlicesInSubpic[subPicIdx] represents the number of slices in the subpicture with an index equal to subPicIdx.

[0297] 1) In one example, NumSlicesInSubpic[subPicIdx] and PicLevelSliceIdx[subPicIdx][SubPicLevelSliceIdx] are derived in a single process by scanning all slices in the order of picture-level slice indices.

[0298] a. Before processing, NumSlicesInSubpic[subPicIdx] is set equal to 0 for all valid subPicIdx.

[0299] b. When checking a slice with picture level index equal to S, if it is in a subpicture with subpicture index equal to P, set PicLevelSliceIdx[P][NumSlicesInSubpic[P]] equal to S, then set NumSlicesInSubpic[P] equal to NumSlicesInSubpic[P]+1.

[0300] ii. In one example, SliceIdxInPic[subPicIdx][SubPicLevelSliceIdx] is used to derive the picture level slice index (eg, picLevelSliceIdx), which is then used to derive the number and / or addresses of CTBs in the slice when parsing the slice header.

[0301] 5. The conforming bitstream requires that a slice cannot be located in multiple sub-pictures.

[0302] 6. The conformance bitstream requires that a sub-picture cannot include two slices (denoted as slice A and slice B), where slice A is in slice A but smaller than slice A, and slice B is in slice B but smaller than slice B, and slice A and slice B are different.

[0303] 7. It is proposed that the slice and / or slice partitioning information of a picture may be signaled in the associated picture header.

[0304] a. In one example, the slice and / or slice partitioning information of a picture is signaled in the PPS or in the associated picture header.

[0305] b. In one example, the slice and / or slice partitioning information of a picture is signaled in the picture header whether it is in the associated picture header.

[0306] i. In one example, if the slice and / or slice partitioning information of a picture is signaled in both the associated PPS and the associated picture header, the slice and / or slice partitioning information of the picture signaled in the picture header will be used.

[0307] ii. In one example, if the slice and / or slice partitioning information of a picture is signaled in both the associated PPS and the associated picture header, the slice and / or slice partitioning information of the picture signaled in the PPS will be used.

[0308] c. In one example, signaling is performed in a video unit at a level higher than a picture, such as in an SPS, to indicate whether the slice and / or slice partitioning information of a picture is signaled in an associated PPS or in an associated picture header.

[0309] 8. It is proposed that when an associated picture is divided into slices in a non-rectangular pattern, the slice partitioning information is signaled in a higher-level video unit (such as PPS and / or picture header) than the slice level.

[0310] a. In one example, when the associated picture is divided into slices in a non-rectangular mode, information indicating the number of slices (eg, num_slices_in_pic_minus1) may be signaled in a higher-level video unit.

[0311] b. In one example, when the associated picture is divided into slices in a non-rectangular pattern, information indicating the index (or address, or position, or coordinates) of the first block unit of the slice is signaled in a higher-level video unit. For example, the block unit may be a CTU or a slice.

[0312] c. In one example, when the associated picture is divided into slices in a non-rectangular pattern, information indicating the number of block units of the slice is signaled in a higher-level video unit. For example, the block unit may be a CTU or a slice.

[0313] d. In one example, when the associated picture is divided in slices in a non-rectangular pattern, the slice partitioning information (eg, num_tiles_in_slice_minus1) is not signaled in the slice header.

[0314] e. In one example, when the associated picture is partitioned into slices in a non-rectangular pattern, the slice index is signaled in the slice header.

[0315] i. In one example, when the associated picture is partitioned into slices in a non-rectangular pattern, slice_address is interpreted as a picture-level slice index.

[0316] f. In one example, when an associated picture is divided into slices in a non-rectangular pattern, partitioning information of each slice in the picture (such as the index of the first block unit and / or the number of block units) may be signaled sequentially in a higher-level video unit.

[0317] i. In one example, when the associated picture is divided into slices in a non-rectangular pattern, the index of the slice may be signaled for each slice in the higher-level video unit.

[0318] ii. In one example, the partitioning information of each stripe is signaled in ascending order of the stripe index.

[0319] 1) In one example, the partitioning information of each slice is signaled in the order of slice 0, slice 1, ..., slice K-1, slice K, slice K+1, ..., slice S-2, slice S-1, where K represents the slice index and S represents the number of slices in the picture.

[0320] iii. In one example, the split information of each stripe is signaled in descending order of stripe index.

[0321] 1) In one example, the partitioning information of each slice is signaled in the order of slice S-2, slice S-1, ..., slice K+1, slice K, slice K-1, ..., slice 1, and slice 0, where K represents the slice index and S represents the number of slices in the picture.

[0322] iv. In one example, when the associated picture is divided into slices in a non-rectangular pattern, the index of the first block unit of the slice may not be signaled in the higher-level video unit.

[0323] 1) For example, the index of the first block unit of stripe 0 (the stripe with stripe index equal to 0) is inferred to be 0.

[0324] 2) For example, the index of the first block unit of stripe K (the stripe with stripe index equal to K, K>0) is inferred to be Among them, N i Indicates the number of block units in stripe i.

[0325] v. In one example, when the associated picture is divided into slices in a non-rectangular pattern, the index of the first block unit of the slice may not be signaled in the higher-level video unit.

[0326] 1) For example, the index of the first block unit of stripe 0 (the stripe with stripe index equal to 0) is inferred to be 0.

[0327] 2) For example, the index of the first block unit of stripe K (the stripe with stripe index equal to K, K>0) is inferred to be Among them, N i Indicates the number of block units in stripe i.

[0328] vi. In one example, when the associated picture is divided into slices in a non-rectangular pattern, the number of block units of the slice may not be signaled in the higher-level video unit.

[0329] 1) When there is only one slice in a picture and there are M block units in the picture, the number of block units of slice 0 is M.

[0330] 2) For example, the number of block units of stripe K (the stripe with stripe index equal to 0) is inferred to be T K+1 -T K, where T K represents the index of the first block unit of stripe K when K < S - 1, where S is the number of stripes in the picture and S > 1.

[0331] 3) For example, the number of block units of stripe S - 1 is inferred as where S is the number of stripes in the picture, S > 1, and M is the number of block units in the picture.

[0332] vii. In one example, when the associated picture is partitioned into stripes in a non - rectangular pattern, the segmentation information of one or more stripes may not be signaled in a higher - level video unit.

[0333] 1) In one example, the segmentation information of one or more stripes not signaled in a higher - level video unit can be inferred from the segmentation information of other stripes to be signaled.

[0334] 2) In one example, the segmentation information of the last C stripes may not be signaled. For example, C equals 1.

[0335] 3) For example, the number of block units of stripe S - 1 is not signaled, where S is the number of stripes in the picture and S > 1.

[0336] a. For example, the number of block units of stripe S - 1 is inferred as where there are M block units in the picture.

[0337] 9. It is proposed that the minimum number of stripes in a picture can be different depending on whether rectangular segmentation or non - rectangular segmentation is applied.

[0338] a. In one example, if the non - rectangular segmentation mode is applied, the picture is partitioned into at least two stripes, while if the rectangular segmentation mode is applied, the picture is partitioned into at least one stripe.

[0339] i. For example, if the non - rectangular segmentation mode is applied, num_slices_in_pic_minus2 plus 2 that specifies the number of stripes in the picture can be signaled.

[0340] b. In one example, if the non - rectangular segmentation mode is applied, the picture is partitioned into at least one stripe, while if the rectangular segmentation mode is applied, the picture is partitioned into at least one stripe.

[0341] i. For example, if the rectangular segmentation mode is applied, num_slices_in_pic_minus2 plus 2 that specifies the number of stripes in the picture can be signaled.

[0342] c. In one example, when a picture is not divided into sub-pictures or is divided into only one sub-picture, the minimum number of slices in the picture may be different depending on whether rectangular partitioning or non-rectangular partitioning is applied.

[0343] 10. It is proposed that when partitioning information is signaled in a video unit such as a PPS or a picture header, a slice is represented by the top left position and the width / height of the slice.

[0344] a. In one example, the index / position / coordinates of the top left block unit (such as a CTU or slice) of the slice are signaled, and / or the width measured in video units (such as a CTU or slice), and / or the height measured in video units (such as a CTU or slice).

[0345] b. In one example, the top left position and width / height information of each stripe is signaled sequentially.

[0346] i. For example, the information of the top left position and width / height of each slice is signaled in ascending order of slice index, such as 0, 1, 2, ..., S-1, where S is the number of slices in the picture.

[0347] c. In one example, the width of the slice minus X may be signaled. For example, X is equal to 1. In one example, slice_width_minus1[i] plus 1 indicates the width of the i-th slice, and slice_width_minus1[i] is signaled. In the present disclosure, "signaling the width of the slice" may mean "signaling the width of the slice minus X."

[0348] d. In one example, the height of the slice minus X may be signaled. For example, X is equal to 1. In one example, slice_height_minus1[i] plus 1 indicates the height of the i-th slice, and slice_height_minus1[i] is signaled. In the present disclosure, "signaling the height of the slice" may mean "signaling the height of the slice minus X."

[0349] e. In one example, whether a stripe is signaled by the top left position and width / height of the stripe may be determined by the stripe signaling method.

[0350] i. In one example, only when the picture is partitioned into rectangular slices, the slices are signaled by the top left position and width / height of the slice.

[0351] f. In one example, whether a slice is signaled by the top left position and width / height of the slice may be determined by the relationship between slice partitioning and sub-picture partitioning.

[0352] i. In one example, the slice is signaled by the top left position and width / height of the slice only when the statement "only one slice per sub-picture" is not true (eg, single_slice_per_subpic_flag is equal to 0).

[0353] g. In one example, whether a slice is signaled by the top left position and width / height of the slice may be determined by the number of slices in the picture.

[0354] i. In one example, slices are signaled by the top left position and width / height of the slice only when the number of slices in a picture is greater than 1 (eg, num_slices_in_pic_minus1>0).

[0355] h. In one example, a syntax element (eg, a flag such as slice_represented_in_ctb_flag[i]) may be signaled to indicate whether the top left position and width / height of the i-th slice is expressed in units of CTU size or slice width / height.

[0356] i. Optionally, a syntax element (eg, a flag such as slice_represented_in_ctb_flag) may be signaled to indicate whether the top left position and width / height of all slices are represented in units of CTU size or slice width / height.

[0357] ii. Optionally, the top left position and width / height of all slices are expressed in units of CTU size.

[0358] i. Whether to signal the x / y coordinates (denoted as slice_top_left_x[i] and slice_top_left_y[i]) and width / height (denoted as slice_width_minus1[i] and slice_height_minus1[i]) of the top left position of the i-th slice may be conditional.

[0359] i. In one example, it can be conditioned on the value of i and / or the CTB size (denoted as CtbSizeY) and / or the width / height of the current picture (denoted as pic_width_in_luma_samples and pic_height_in_luma_samples) and / or the number of slices in the picture (denoted as num_slices_in_pic_minus1).

[0360] ii. Exemplary conditional signaling is shown in the syntax table below.

[0361]

[0362] j. When at least one of the x-coordinate / y-coordinate of the top left position of the i-th slice (denoted as slice_top_left_x[i] and slice_top_left_y[i]) and the width / height (denoted as slice_width_minus1[i] and slice_height_minus1[i]) is not signaled, a default value may be inferred.

[0363] i. In one example, the default value may be zero.

[0364] ii. In one example, the default value may depend on slice_represented_in_ctb_flag[i].

[0365] iii. For example, when not present, the value of slice_top_left_x[i] is inferred to be equal to 0.

[0366] iv. For example, when not present, the value of slice_top_left_y[i] is inferred to be equal to 0.

[0367] v. For example, when not present, the value of slice_width_minus1[i] is inferred to be equal to (slice_represented_in_ctb_flag[i] ? ((pic_width_in_luma_samples + CtbSizeY - 1) >> CtbLog2SizeY): NumTileColumns) - slice_top_left_x[i] – 1.

[0368] vi. For example, when not present, the value of slice_height_minus1[i] is inferred to be equal to (slice_represented_in_ctb_flag[i] ? ((pic_height_in_luma_samples + CtbSizeY - 1) >> CtbLog2SizeY): NumTileRows) - slice_top_left_y[i] – 1.

[0369] 11. It is proposed to signal the partitioning information (such as position / width / height) of slices in sub-pictures in video units such as SPS / PPS / picture header.

[0370] a. In one example, the slice partitioning information of each sub-image is signaled sequentially.

[0371] i. For example, the slice partitioning information of each sub-image is signaled in ascending order of the sub-image index.

[0372] b. In one example, the partitioning information (such as position / width / height) of each slice in the sub-image is signaled sequentially.

[0373] i. In one example, the partitioning information (eg, position / width / height) of each slice in a sub-picture is signaled in ascending order of the sub-picture level slice index.

[0374] 12. It is proposed that the difference between the tile index of the first tile in the i-th rectangular slice and the tile index of the first tile in the i+1-th rectangular slice (denoted as tile_idx_delta[i]) is derived instead of signaling.

[0375] a. In one example, based on the rectangular strips from the 0th rectangular strip to the ith rectangular strip, a slice index of the first slice in the (i+1)th rectangular strip is derived.

[0376] b. In one example, the tile index of the first tile in the (i+1)th rectangular strip is derived as the minimum index of tiles that are not within the rectangular strips from the 0th rectangular strip to the i-th rectangular strip.

[0377] 13. It is proposed to signal information used to derive the number of slice columns / slice rows (eg, NumTileColumns or NumTileRows) based on the relationship between the width of the picture and the size of the CTU.

[0378] a. For example, if the width of the picture is less than or equal to the size or width of the CTU, num_exp_tile_columns_minus1 and / or tile_column_width_minus1 may not be signaled.

[0379] b. For example, if the height of the picture is less than or equal to the size or height of the CTU, num_exp_tile_rows_minus1 and / or tile_row_height_minus1 may not be signaled.

[0380] 14. When slice_subpic_id exists, there must be only one CurrSubpicIdx that satisfies SubpicIdVal[CurrSubpicIdx] equal to slice_subpic_id.

[0381] 15. If rect_slice_flag is equal to 0 or subpic_info_present_flag is equal to 0, the value of slice_address+i (where i is in the range of 0 to num_tiles_in_slice_minus1, inclusive) shall not be equal to the value of slice_address+j (where j is in the range of 0 to num_tiles_in_slice_minus1, inclusive) of any other coded slice NAL unit of the same coded picture, where i is in that range.

[0382] 16. In the case where there are both uniformly spaced and non-uniformly spaced slices in a picture, a syntax element may be signaled in the PPS (or SPS) to specify the type of slice layout.

[0383] a. In one example, a syntax flag may be signaled in the PPS to specify whether the slice layout is non-uniform spacing followed by uniform spacing, or uniform spacing followed by non-uniform spacing.

[0384] b. For example, whenever there are non-uniformly spaced tiles, the number of tile columns / rows explicitly provided (eg, num_exp_tile_columns_minus1, num_exp_tile_rows_minus1) may be no less than the total number of non-uniform tiles.

[0385] c. For example, whenever there are evenly spaced tiles, the number of tile columns / rows explicitly provided (eg, num_exp_tile_columns_minus1, num_exp_tile_rows_minus1) may be less than or equal to the total number of evenly spaced tiles.

[0386] d. If the slice layout is similar to evenly spaced followed by non-evenly spaced (i.e., the picture starts with evenly spaced slices and ends with multiple non-evenly spaced slices),

[0387] i. In one example, the widths of the tile columns of the non-uniformly spaced tiles located at the back of the picture can be first assigned in reverse order (i.e., the order of tile indices is equal to NumTileColumns, NumTileColumns-1, NumTileColumns-2, ...), and then the widths of the tile columns of the evenly spaced tiles located at the front of the picture can be implicitly derived in reverse order (i.e., the order of tile indices is equal to NumTileColumns-T, NumTileColumns-T-1, ..., 2, 1, 0, where T represents the number of non-uniform tile columns).

[0388] 17. The syntax element that specifies the difference between representative slice indices of two rectangular stripes can be used only if the condition is true, where one of the two rectangular stripes is the i-th stripe (e.g., tile_idx_delta[i]).

[0389] a. In one example, the condition is (i < num_slices_in_pic_minus1), where num_slices_in_pic_minus1 + 1 represents the number of stripes in the picture.

[0390] b. In one example, the condition is (i!= num_slices_in_pic_minus1), where num_slices_in_pic_minus1 + 1 represents the number of stripes in the picture.

[0391] 18. Whether and / or how to signal or interpret or limit the size of the Merge Estimation Region (MER) (e.g., signaled by log2_parallel_merge_level_minus2) may depend on the minimum allowable codec block size (e.g., signaled / represented as log2_min_luma_coding_block_size_minus2 and / or MinCbSizeY).

[0392] a. In one example, it is required that the size of the MER is not less than the minimum allowable codec block size.

[0393] i. For example, it is required that log2_parallel_merge_level_minus2 shall be equal to or greater than log2_min_luma_coding_block_size_minus2.

[0394] ii. For example, it is required that log2_parallel_merge_level_minus2 is in the range from log2_min_luma_coding_block_size_minus2 to CtbLog2SizeY – 2.

[0395] b. In one example, the difference between Log2(MER size) and Log2(MinCbSizeY) is signaled, which is represented as log2_parallel_merge_level_minus_log2_mincb.

[0396] i. For example, log2_parallel_merge_level_minus_log2_mincb is coded by unary code (ue).

[0397] ii. For example, log2_parallel_merge_level_minus_log2_mincb is required to be in the range of 0 to CtbLog2SizeY-log2_min_luma_coding_block_size_minus2–2.

[0398] iii. For example, Log2ParMrgLevel=log2_parallel_merge_level_minus_log2_mincb+log2_min_luma_coding_block_size_minus2+2, where Log2ParMrgLevel is used to control the MER size.

[0399] 19. It is proposed that when num_exp_slices_in_tile[i] is equal to 0, the slice height of the i-th slice in units of CTU rows is derived, for example, represented as sliceHeightInCtus[i].

[0400] a. In one example, when num_exp_slices_in_tile[i] is equal to 0, sliceHeightInCtus[i] is derived to be equal to RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns].

[0401] 20. It is proposed that the num_exp_slices_in_tile[i]-1th slice in the slice containing the i-th slice in the picture is always present, and the height is always exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1]+1 CTU rows.

[0402] a. Optionally, the num_exp_slices_in_tile[i]-1th slice in the slice containing the i-th slice in the picture may or may not exist, and the height is less than or equal to exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1]+1 CTU rows.

[0403] 21. It is proposed that during the derivation of information of rectangular slices, the variable tileIdx is only updated for slices with picture-level slice indices less than num_slices_in_pic_minus1, ie, the variable tileIdx is not updated for the last slice in each picture of the reference PPS.

[0404] 22. It is proposed that the num_exp_tile_columns_minus1-th tile column always exists in the picture of the reference PPS, and the width is always tile_column_width_minus1[num_exp_tile_columns_minus1]+1 CTB.

[0405] 23. It is proposed that the num_exp_tile_rows_minus1th tile row always exists in the picture of the reference PPS, and the height is always tile_column_height_minus1[num_exp_tile_rows_minus1]+1 CTBs.

[0406] 24. It is proposed that when the maximum picture width and the maximum picture height are both less than CtbSizeY, the signaling notification of the syntax element sps_num_subpics_minus1 can be skipped.

[0407] a. Optionally, in addition, when the above condition is true, the value of sps_num_subpics_minus1 is inferred to be equal to 0.

[0408] 25. It is proposed that when the picture width is not greater than CtbSizeY, the signaling of the syntax element num_exp_tile_columns_minus1 can be skipped.

[0409] b. Optionally, in addition, when the above condition is true, the value of num_exp_tile_columns_minus1 is inferred to be equal to 0.

[0410] 26. It is proposed that when the picture height is not greater than CtbSizeY, the signaling notification of the syntax element num_exp_tile_rows_minus1 can be skipped.

[0411] c. Optionally, in addition, when the above condition is true, the value of num_exp_tile_row_minus1 is inferred to be equal to 0.

[0412] 27. It is proposed that when num_exp_tile_columns_minus1 is equal to PicWidthInCtbsY-1, the signaling of the syntax element tile_column_width_minus1[i] can be skipped, and i ranges from 0 to num_exp_tile_columns_minus1 (inclusive).

[0413] d. Optionally, in addition, the value of tile_column_width_minus1[i] is inferred to be equal to 0.

[0414] 28. It is proposed that when num_exp_tile_rows_minus1 is equal to PicHeightInCtbsY-1, the signaling of the syntax element tile_row_height_minus1[i] can be skipped, and i ranges from 0 to num_exp_tile_rows_minus1 (inclusive).

[0415] e. Optionally, in addition, the value of tile_row_height_minus1[i] is inferred to be equal to 0.

[0416] 29. The height of uniform slices that partition a tile is indicated by the last entry of exp_slice_height_in_ctus_minus1[] which indicates the height of a slice in the tile. Non-uniform slices are slices below the explicitly signaled slices. For example: uniformSliceHeight = exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1]+1

[0417] 30. It is proposed that the width of the 'num_exp_tile_columns_minus1'th tile column is not allowed to be reset, ie the width can be derived directly using the parsed value from the bitstream (eg, represented by tile_column_width_minus1[num_exp_tile_columns_minus1]) without referring to other information.

[0418] a. In one example, the width of the 'num_exp_tile_columns_minus1'th tile column is directly set to tile_column_width_minus1[num_exp_tile_columns_minus1] plus 1. Optionally, in addition, tile_column_width_minus1[num_exp_tile_columns_minus1] is used to derive the width of tile columns with indices greater than num_exp_tile_columns_minus1, for example as specified in clause 6.5.1.

[0419] b. Similarly, no reset is allowed for the height of the num_exp_tile_columns_minus1th tile row, i.e., the height can be derived directly using the parsed value from the bitstream (e.g., represented by tile_row_height_minus1[num_exp_tile_columns_minus1]) without referring to other information.

[0420] i. In one example, the height of the 'num_exp_tile_columns_minus1'th tile row is directly set to tile_row_height_minus1[num_exp_tile_columns_minus1] plus 1. Optionally, in addition, tile_row_height_minus1[num_exp_tile_columns_minus1] is used to derive the height of tile rows with indices greater than num_exp_tile_columns_minus1, for example as specified in clause 6.5.1.

[0421] 31. It is proposed that the height of the num_exp_slices_in_tile[i]–1th slice in a slice is not allowed to be reset, that is, the height can be derived directly using the parsed value from the bitstream (e.g., represented by exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1]) without referring to other information.

[0422] a. In one example, the height of the num_exp_slices_in_tile[i]–1th slice in a slice is directly set to exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]–1] plus 1. Optionally, in addition, exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]–1] is used to derive the height of slices with indices greater than num_exp_slices_in_tile[i]-1.

[0423] 32. Propose to use exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1] to derive uniform slice heights instead of specifying the height of the num_exp_slices_in_tile[I]–1th slice.

[0424] a. Optionally, exp_slice_height_in_ctus_minus[i][num_exp_slices_in_tile[i]-1] is used to derive a uniform slice height and specifies the height of the num_exp_slices_in_tile[i]–1th slice.

[0425] b. Optionally, use exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1] to derive uniform slice height. In some cases, it may specify the height of the num_exp_slices_in_tile[i]–1th slice, but in some cases, it may not specify the height of the num_exp_slices_in_tile[i]–1th slice.

[0426] 33. It is proposed that firstRemainingWidthInCtbsY should be equal to or greater than uniformTileColWidth, where the variables firstRemainingWidthInCtbsY and uniformTileColWidth are calculated as follows:

[0427]

[0428] 34. It is proposed that firstRemainingHeightInCtbsY should be equal to or greater than uniformTileRowHeight, where the variables firstRemainingHeightInCtbsY and uniformTileRowHeight are calculated as follows:

[0429]

[0430] 35. It is proposed that firstRemainingHeightInCtbsY should be equal to or greater than uniformSliceHeight, where the variables firstRemainingHeightInCtbsY and uniformSliceHeight are calculated as follows:

[0431]

[0432] 36. A syntax element (e.g., denoted as SE_x) is proposed to indicate the maximum number of affine merge candidates allowed in a sub-block based merge candidate list.

[0433] a. In one example, the signaling of SE_x is conditional on whether affine prediction is enabled. For example, SE_x is signaled only when affine prediction is enabled.

[0434] b. In one example, if SE_x does not exist, SE_x is set equal to a default value. For example, SE_x is set equal to a default value so that the maximum number of affine merge candidates allowed in the sub-block-based merge candidate list is zero.

[0435] c. In one example, the maximum number of affine merge candidates allowed in the sub-block based merge candidate list is set equal to X-SE_x, where X is an integer (such as 5).

[0436] d. In one example, SE_x is not allowed to be greater than X, where X is an integer (such as 5).

[0437] e. In one example, SE_x should be in a range such as 0 to X (inclusive), where X is an integer (such as 5).

[0438] f. In one example, the maximum number of merge candidates allowed in the sub-block based merge candidate list (denoted as MaxNumSubblockMergeCand) can be derived based on SE_x.

[0439] i. In one example, MaxNumSubblockMergeCand can be derived based on SE_x and the maximum number of allowed sbTMVPmerge candidates.

[0440] ii. In one example, MaxNumSubblockMergeCand should be in the range of, for example, 0 to X (inclusive), where X is an integer (such as 5).

[0441] 1) In one example, MaxNumSubblockMergeCand is clipped into the range.

[0442] iii. In one example, MaxNumSubblockMergeCand is not allowed to be greater than X, where X is an integer (such as 5).

[0443] 1) In one example, MaxNumSubblockMergeCand is clipped to be no larger than X.

[0444] iv. In one example, MaxNumSubblockMergeCand is derived as MaxNumSubblockMergeCand=Min(5,(sps_sbtmvp_enabled_flag&&ph_temporal_mvp_enable_flag)+5−five_minus_max_num_affine_merge_cand), where five_minus_max_num_affine_merge_cand is the syntax element SE_x.

[0445] 6. Examples

[0446] In the following examples, added parts are marked as bold text, underlined text and italic text. Deleted parts are marked in [[ ]].

[0447] 6.1. Example 1: Example sub-picture level strip index change

[0448] 3 Definition

[0449] Picture level slice index: When rect_slice_flag is equal to 1, [[one]] slice index in the slice list in the picture (in the order signaled in the PPS).

[0450] [[Sub-picture level slice index: When rect_slice_flag is equal to 1, the slice index of the slice list in the sub-picture (in the order signaled in the PPS).]]

[0451]

[0452] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0453] …

[0454] [[List NumSlicesInSubpic[i], specifies the number of rectangular slices in the i-th sub-picture, The deduction is as follows:

[0455]

[0456] 7.4.8.1 Common Strip Header Semantics

[0457] …

[0458] Specifies the slice address of the slice. When not present, the value of slice_address is inferred to be equal to 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 equal to 0.

[0459] If rect_slice_flag is equal to 0, the following applies:

[0460] - The strip address is the raster scan slice index.

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

[0462] -slice_address values ​​should be in the range of 0 to NumTilesInPic-1 (inclusive).

[0463] Otherwise (rect_slice_flag is equal to 1), the following applies:

[0464] - Stripe address is The sub-picture level strip index of the strip,

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

[0466] -slice_address values ​​should be in the range of 0 to NumSlicesInSubpic[CurrSubpicIdx]-1 (inclusive).

[0467] A requirement for bitstream conformance is that the following constraints apply:

[0468] - If rect_slice_flag is equal to 0 or subpic_info_present_flag is equal to 0, the value of slice_address shall not be equal to the value of slice_address of any other codec slice NAL unit of the same codec picture.

[0469] Otherwise, the pair of slice_subpic_id value and slice_address value shall not be equal to the pair of slice_subpic_id value and slice_address value of any other codec slice NAL unit of the same codec picture.

[0470] - The shape of the slices of a picture shall be such that, when decoded, the entire left boundary and the entire top boundary of each CTU shall consist of the picture boundary or of the boundary of the previously decoded CTU(s).

[0471] …

[0472] Add 1 (when present) to specify the number of tiles in the slice. The value of num_tiles_in_slice_minus1 should be in the range of 0 to NumTilesInPic-1 (inclusive).

[0473] The variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice and the list CtbAddrInCurrSlice[i] that specifies the picture raster scan address of the i-th CTB in the slice (where i ranges from 0 to NumCtusInCurrSlice-1 (inclusive)) are derived as follows:

[0474]

[0475]

[0476] 6.2. Example 2: Signaling strips in PPS for non-rectangular patterns

[0477] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0478]

[0479]

[0480] 7.3.7.1 General Strip Header Syntax

[0481]

[0482]

[0483] 7.4.3.4 Picture Parameter Set RBSP Semantics

[0484] num_slices_in_pic_minus1 plus 1 specifies the number of [[rectangular]] slices in each picture referencing the PPS. The value of num_slices_in_pic_minus1 shall be in the range of 0 to MaxSlicesPerPicture-1, inclusive, where MaxSlicesPerPicture is specified in Annex A. When no_pic_partition_flag is equal to 1, the value of num_slices_in_pic_minus1 is inferred to be equal to 0.

[0485]

[0486]

[0487] 7.4.8.1 Common Strip Header Semantics

[0488] …

[0489] Slice address of the slice. When not present, the value of slice_address is inferred to be equal to 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 equal to 0. When rect_slice_flag is equal to 0 and NumSlicesInPic is equal to 1, the value of slice_address is inferred to be equal to 0.

[0490] If rect_slice_flag is equal to 0, the following applies:

[0491] - The strip address is [[raster scan slice index]]

[0492] -The length of slice_address is Ceil(Log2( [[NumTilesInPic]])) positions.

[0493] -slice_address value should be between 0 and The value is in the range of [[NumTilesInPic]] - 1 (inclusive).

[0494] Otherwise (rect_slice_flag is equal to 1), the following applies:

[0495] - The slice address is the sub-picture level slice index of the slice.

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

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

[0498] A requirement for bitstream conformance is that the following constraints apply:

[0499] -[[If rect_slice_flag is equal to 0 or subpic_info_present_flag is equal to 0, the value of slice_address shall not be equal to the value of slice_address of any other codec slice NAL unit of the same codec picture.

[0500] -otherwise, Then the pair of slice_subpic_id value and slice_address value shall not be equal to the pair of slice_subpic_id value and slice_address value of any other codec slice NAL unit of the same codec picture.

[0501] - The shape of the slices of a picture shall be such that, when decoded, the entire left boundary and the entire top boundary of each CTU shall consist of the picture boundary or of the boundary of the previously decoded CTU(s).

[0502] …

[0503] The variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice and the list CtbAddrInCurrSlice[i] that specifies the picture raster scan address of the i-th CTB in the slice (where i ranges from 0 to NumCtusInCurrSlice-1 (inclusive)) are derived as follows:

[0504]

[0505] 6.3. Example 3: Signaling Slices Conditioned by Image Dimension

[0506] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0507]

[0508]

[0509]

[0510] 6.4. Example 4: Example 1 on the semantics of tile_column_width_minus1 and tile_row_height_minus1

[0511] 7.4.3.4 Picture Parameter Set RBSP Semantics

[0512] …

[0513] [i] Plus 1 provision The width of the i-th tile column in CTBs, where i ranges 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 with indices 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] shall be in the range of 0 to PicWidthInCtbsY-1, inclusive. When not present, the value of tile_column_width_minus1[0] is inferred to be equal to PicWidthInCtbsY1-1.

[0514] [i] Plus 1 provision The height of the i-th tile row in CTBs, where i ranges 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 tile rows whose indices are 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] shall be in the range of 0 to PicHeightInCtbsY-1, inclusive. When not present, the value of tile_row_height_minus1[0] is inferred to be equal to PicHeightInCtbsY1-1.

[0515] …

[0516] 6.5. Example 5: Example 2 on the semantics of tile_column_width_minus1 and tile_row_height_minus1

[0517] 7.4.3.4 Picture Parameter Set RBSP Semantics

[0518] …

[0519] [i] plus 1 specifies the width of the i-th slice column in CTB units, and the range of i is 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 with indices 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] shall be in the range 0 to PicWidthInCtbsY-1, inclusive. When not present, the value of tile_column_width_minus1[0] is inferred to be equal to PicWidthInCtbsY-1.

[0520] [i] plus 1 specifies the height of the i-th slice row in CTB units, i ranges 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 tile rows with indices 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] shall be in the range 0 to PicHeightInCtbsY-1, inclusive. When not present, the value of tile_row_height_minus1[0] is inferred to be equal to PicHeightInCtbsY-1.

[0521] …

[0522] 6.6. Example 6: Example Derivation of CTUs in a Strip

[0523] 6.5 Scanning Process

[0524] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0525] …

[0526] For rectangular slices, the list NumCtusInSlice[i] specifying the number of CTUs in the i-th slice, where i ranges from 0 to num_slices_in_pic_minus1 (inclusive), the list SliceTopLeftTileIdx[i] specifying the index of the top left slice of the slice, where i ranges from 0 to num_slices_in_pic_minus1 (inclusive), and the matrix CtbAddrInSlice[i][j] specifying the picture raster scan address of the j-th CTB in the i-th slice, where i ranges from 0 to num_slices_in_pic_minus1 (inclusive) and j ranges from 0 to NumCtusInSlice[i]-1 (inclusive), are derived as follows:

[0527]

[0528]

[0529]

[0530] 6.7. Example 7: Signaling of MER Size

[0531] 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0532]

[0533] 7.4.3.3 Sequence Parameter Set RBSP Semantics

[0534] Adding log2_min_luma_coding_block_size_minus2+2 specifies the value of the variable Log2ParMrgLevel, which is used in the derivation process of spatial merge candidates as specified in clause 8.5.2.3, the derivation process of motion vectors and reference indices in sub-block merge mode as specified in clause 8.5.5.2, and is used to control the call of the update process of the history-based motion vector prediction value list in clause 8.5.2.1. The value of should be in the range of 0 to CtbLog2SizeY-log2_min_luma_coding_block_size_minus2-2 (inclusive). The derivation of the variable Log2ParMrgLevel is as follows:

[0535] Log2ParMrgLevel=log2_parallel_merge_level_minus2+log2_min_luma_coding_block_size_minus2+2 (68)

[0536] 6.8. Example 8: Signaling for rectangular strips

[0537] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0538] …

[0539] The list ctbToSubpicIdx[ctbAddrRs] that specifies the conversion from CTB addresses in the picture raster scan to sub-picture indices (where ctbAddrRs ranges from 0 to PicSizeInCtbsY-1 (inclusive)) is derived as follows:

[0540]

[0541]

[0542] When rect_slice_flag is equal to 1, a list NumCtusInSlice[i] specifying the number of CTUs in the i-th slice, where i ranges from 0 to num_slices_in_pic_minus1, inclusive; a list SliceTopLeftTileIdx[i] specifying the slice index of the slice containing the first CTU in the slice, where i ranges from 0 to num_slices_in_pic_minus1, inclusive; a matrix CtbAddrInSlice[i][j] specifying the picture raster scan address of the j-th CTB in the i-th slice, where i ranges from 0 to num_slices_in_pic_minus1, inclusive and j ranges from 0 to NumCtusInSlice[i]-1, inclusive; and The derivation is as follows:

[0543]

[0544]

[0545]

[0546] It is a requirement of bitstream conformance that the value of NumCtusInSlice[i], where i ranges from 0 to num_slices_in_pic_minus1, inclusive, shall be greater than 0. Furthermore, it is a requirement of bitstream conformance that the matrix CtbAddrInSlice[i][j], where i ranges from 0 to num_slices_in_pic_minus1, inclusive, and j ranges from 0 to NumCtusInSlice[i]-1, inclusive, shall include each of all CTB addresses in the range 0 to PicSizeInCtbsY-1, inclusive, once and only once.

[0547] …

[0548] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0549]

[0550]

[0551] 7.4.3.4 Picture parameter set semantics

[0552] …

[0553] When tile_idx_delta_present_flag is equal to 1, it specifies that the tile_idx_delta[i] syntax element may be present in the PPS, and all rectangular slices in the pictures referencing the PPS are specified with increasing values ​​of i in the order indicated by the value of tile_idx_delta[i]. When not present, the value of tile_idx_delta_present_flag is inferred to be equal to 0.

[0554] [i] plus 1 specifies the width of the i-th rectangular slice in units of tile columns. The value of slice_width_in_tiles_minus1[i] shall be in the range of 0 to NumTileColumns-1 (inclusive).

[0555] When i is less than num_slices_in_pic_minus1 and NumTileColumns is equal to 1, the value of slice_width_in_tiles_minus1[i] is inferred to be equal to 0.

[0556] When num_exp_slices_in_tiles_MINUS1[i] is equal to 0, [i] plus 1 specifies the height of the i-th rectangular slice in tile rows. The value of slice_height_in_tiles_minus1[i] shall be in the range of 0 to NumTileRows-1 (inclusive).

[0557] When i is less than num_slices_in_pic_minus1 and slice_height_in_tiles_minus1[i] does not exist, it is inferred to be equal to NumTileRows==1?0:slice_height_in_tiles_MINUS1[i-1].

[0558] [i] specifies the number of explicitly provided slice heights for the slice in the slice containing the i-th slice (i.e., the slice with slice index equal to SliceTopLeftTileIdx[i]). The value of num_exp_slices_in_tile[i] should be in the range of 0 to RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - 1, inclusive. When not present, the value of num_exp_slices_in_tile[i] is inferred to be equal to 0.

[0559]

[0560] [i] Provisions The value of tile_idx_delta[i] shall be in the range -NumTilesInPic+1 to NumTilesInPic-1 (inclusive). When not present, the value of tile_idx_delta[i] is inferred to be equal to 0. When present, the value of tile_idx_delta[i] shall not be equal to 0.

[0561] …

[0562] 6.9. Example 9: Signaling for rectangular strips

[0563] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0564] …

[0565] When rect_slice_flag is equal to 1, a list NumCtusInSlice[i] that specifies the number of CTUs in the i-th slice (where i ranges from 0 to num_slices_in_pic_minus1 (inclusive)), a list SliceTopLeftTileIdx[i] that specifies the slice index of the slice containing the first CTU in the slice (where i ranges from 0 to num_slices_in_pic_minus1 (inclusive)), a list The matrix CtbAddrInSlice[i][j] of the picture raster scan addresses of the j-th CTB, where i ranges from 0 to num_slices_in_pic_minus1 (inclusive) and j ranges from 0 to NumCtusInSlice[i]-1 (inclusive), and the variable NumSlicesInTile[i] that specifies the number of slices in the slice containing the i-th slice (i.e., the slice with slice index equal to SliceTopLeftTileIdx[i]), are derived as follows:

[0566]

[0567]

[0568]

[0569] Optionally, above, the following line:

[0570]

[0571] Modify to the following;

[0572]

[0573] 6.10. Example 10: Signaling of Sub-Pictures and Slices

[0574] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0575] The variable NumTileColumns that specifies the number of tile columns and the list colWidth[i] that specifies the width of the i-th tile column in CTB units (where i ranges from 0 to NumTileColumns-1 (inclusive)) are derived as follows:

[0576]

[0577]

[0578] The variable NumTileRows that specifies the number of tile rows and the list RowHeight[j] that specifies the height of the j-th tile row in CTB units (where j ranges from 0 to NumTileRows-1 (inclusive)) are derived as follows:

[0579]

[0580] 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0581]

[0582] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0583]

[0584]

[0585] 7.4.3.4 Picture parameter set semantics

[0586] …

[0587] Add 1 to specify 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).

[0588] Add 1 to specify 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).

[0589] [i] plus 1 specifies the width of the i-th slice column in CTB units, and the range of i is 0 to (Inclusive). tile_column_width_minus1[num_exp_tile_columns_minus1] is used to derive the index The width of the tile column of num_exp_tile_columns_minus1 as specified in clause 6.5.1. The value of tile_column_width_minus1[i] shall be in the range 0 to PicWidthInCtbsY-1 (inclusive). When not present, the value of tile_column_width_minus1[i] is inferred to be equal to

[0590] [i] plus 1 specifies the height of the i-th slice row in CTB units, i ranges from 0 to (Inclusive). tile_row_height_minus1[num_exp_tile_rows_minus1] is used to derive the index The height of a tile row of num_exp_tile_rows_minus1 as specified in clause 6.5.1. The value of tile_row_height_minus1[i] shall be in the range 0 to PicHeightInCtbsY-1 (inclusive). When not present, the value of tile_row_height_minus1[i] is inferred to be equal to

[0591] 6.11. Example 11: Example semantic changes

[0592] [i][j] plus 1 specifies the height of the jth rectangular strip in the slice containing the i-th strip in units of CTU rows. The value of exp_slice_height_in_ctus_minus1[i][j] should be in the range of 0 to RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1 (inclusive).

[0593] 6.12. Example 12: Example consistency requirements

[0594] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Image Scanning Process

[0595] The variable NumTileColumns that specifies the number of tile columns and the list colWidth[i] that specifies the width of the i-th tile column in CTB units (where i ranges from 0 to NumTileColumns-1 (inclusive)) are derived as follows:

[0596]

[0597]

[0598] The variable NumTileRows that specifies the number of tile rows and the list RowHeight[j] that specifies the height of the j-th tile row in units of CTB (where j ranges from 0 to NumTileRows-1 (inclusive)) are derived as follows:

[0599]

[0600]

[0601] 6.13. Example 12: Example Strip Split Signaling

[0602] 6.5.1 CTB Raster Scanning, Slice Scanning, and Sub-Picture Scanning Process

[0603] …

[0604] When rect_slice_flag is equal to 1, the list NumCtusInSlice[i] specifying the number of CTUs in the i-th slice (where i ranges from 0 to num_slices_in_pic_minus1 (inclusive)), the list SliceTopLeftTileIdx[i] specifying the slice index of the slice containing the first CTU in the slice (where i ranges from 0 to num_slices_in_pic_minus1 (inclusive))]], the matrix CtbAddrInSlice[i][j] specifying the picture raster scan address of the j-th CTB in the i-th slice (where i ranges from 0 to num_slices_in_pic_minus1 (inclusive) and j ranges from 0 to NumCtusInSlice[i]-1 (inclusive)), and the variable NumSlicesInTile[i]]] specifying the number of slices containing the i-th slice are derived as follows:

[0605]

[0606]

[0607]

[0608] Among them, the function AddCtbsToSlice(sliceIdx, startX, stopX, startY, stopY) is defined as follows:

[0609]

[0610] 7.3.2.4 Picture Parameter Set RBSP Syntax

[0611]

[0612]

[0613] Specifies the number of rectangular slices in each picture of the referenced PPS, plus 1. The value of num_slices_in_pic_minus1 shall be in the range of 0 to MaxSlicesPerPicture-1, inclusive, where MaxSlicesPerPicture is specified in Annex A. When no_pic_partition_flag is equal to 1, the value of num_slices_in_pic_minus1 is inferred to be equal to 0. When single_slice_per_subpic_flag is equal to 1, the value of num_slices_in_pic_minus1 is inferred to be equal to sps_num_subpics_minus1.

[0614] When tile_idx_delta_present_flag is equal to 1, it specifies that the tile_idx_delta[i] syntax element may be present in the PPS, and all rectangular slices in the pictures referencing the PPS are specified with increasing values ​​of i in the order indicated by the value of tile_idx_delta[i]. When not present, the value of tile_idx_delta_present_flag is inferred to be equal to 0.

[0615] [i] plus 1 specifies the width of the i-th rectangular slice in tile columns. The value of slice_width_in_tiles_minus1[i] shall be in the range of 0 to NumTileColumns-1 (inclusive). When i is less than num_slices_in_pic_minus1 and NumTileColumns is equal to 1, the value of slice_width_in_tiles_minus1[i] is inferred to be equal to 0.

[0616] [i] plus 1 specifies the height in tile rows of the i-th rectangular slice when num_exp_slices_in_tiles_minus1[i] is equal to 0. The value of slice_height_in_tiles_minus1[i] shall be in the range of 0 to NumTileRows-1 (inclusive).

[0617] When i is less than num_slices_in_pic_minus1 and slice_height_in_tiles_minus1[i] does not exist, it is inferred to be equal to NumTileRows==1?0:slice_height_in_tiles_minus1[i-1].

[0618] [i] specifies the number of explicitly provided slice heights for the slice containing the i-th slice (i.e., the slice with slice index equal to SliceTopLeftTileIdx[i]). The value of num_exp_slices_in_tile[i] should be in the range of 0 to RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - 1, inclusive. When not present, the value of num_exp_slices_in_tile[i] is inferred to be equal to 0.

[0619] NOTE 3 - The slice containing the i-th slice is not divided into multiple slices if num_exp_slices_in_tile[i] is equal to 0. Otherwise (num_exp_slices_in_tile[i] is greater than 0), the slice containing the i-th slice may or may not be divided into multiple slices.

[0620] [i][j] plus 1 specifies the height of the j-th rectangular slice in CTU rows in the slice containing the i-th slice. The value of exp_slice_height_in_ctus_minus1[i][j] shall be in the range of 0 to RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1, inclusive.

[0621] [i] specifies the difference between the slice index of the slice containing the first CTU in the (i+1)th rectangular slice and the slice index of the slice containing the first CTU in the (i)th rectangular slice. The value of tile_idx_delta[i] shall be in the range -NumTilesInPic+1 to NumTilesInPic-1, inclusive. When not present, the value of tile_idx_delta[i] is inferred to be equal to 0. When present, the value of tile_idx_delta[i] shall not be equal to 0. ]]

[0622]

[0623]

[0624] 6.14. Example 12: Signaling of Merge Candidate List Size Based on Example Sub-Blocks

[0625] 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0626]

[0627] 7.4.3.3 Sequence Parameter Set RBSP Semantics

[0628] Specifies the maximum number of subblock-based merge motion vector prediction candidates supported in the SPS, minus 5. The value of five_minus_max_num_subblock_merge_cand shall be in the range of 0 to 5 (inclusive). ]]

[0629]

[0630] 7.4.3.7 Image Header Structure Semantics

[0631] Specifies whether the temporal motion vector predictor can be used for inter prediction of slices associated with the PH. If ph_temporal_mvp_enabled_flag is equal to 0, the syntax elements of the slices associated with the PH will be constrained so that the temporal motion vector predictor is not used in the decoding of the slices. Otherwise (ph_temporal_mvp_enabled_flag is equal to 1), the temporal motion vector predictor can be used for decoding the slices associated with the PH. When not present, the value of ph_temporal_mvp_enabled_flag is inferred to be equal to 0. The value of ph_temporal_mvp_enabled_flag shall be equal to 0 when there is no reference picture in the DPB with the same spatial resolution as the current picture.

[0632] The maximum number of sub-block-based merge MVP candidates, MaxNumSubblockMergeCand, is derived as follows:

[0633]

[0634] Figure 7is a block diagram illustrating an example video processing system 1900 in which the various techniques disclosed herein may be implemented. Various implementations may include some or all of the components of 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-bit or 10-bit multi-component pixel values), or may be received 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 (e.g., Ethernet, passive optical network (PON), etc.), and wireless interfaces (e.g., Wi-Fi or cellular interfaces).

[0635] System 1900 may include a codec component 1904 that implements the various codecs or encoding methods described in this document. The codec component 1904 can reduce the average bit rate of the video from the input 1902 to the output of the codec component 1904 to generate a codec representation of the video. Therefore, codec technology is sometimes referred to as video compression or video transcoding technology. The output of the codec component 1904 can be stored or transmitted via a communication connected to the component 1906. The stored or transmitted bitstream (or codec) representation of the video received at the input 1902 can be used by component 1908 to generate pixel values ​​or displayable video sent to the display interface 1910. The process of generating a user-viewable video based on the bitstream is sometimes referred to as video decompression. In addition, although some video processing operations are referred to as "codec" operations or tools, it will be understood that the codec tools or operations are used at the encoder, and the corresponding decoding tools or operations that reverse the codec results will be performed by the decoder.

[0636] Examples of peripheral bus interfaces or display interfaces may include Universal Serial Bus (USB), High-Definition Multimedia Interface (HDMI), or DisplayPort, etc. Examples of storage interfaces include SATA (Serial Advanced Technology Attachment), PCI, IDE interfaces, etc. The technology described in this document can be embodied in various electronic devices, such as mobile phones, laptop computers, smartphones, or other devices capable of performing digital data processing and / or video display.

[0637] Figure 836 is a block diagram of a video processing device 3600. Device 3600 can be used to implement one or more methods described herein. Device 3600 can be embodied in a smartphone, tablet computer, computer, Internet of Things (IoT) receiver, etc. Device 3600 may include one or more processors 3602, one or more memories 3604, and video processing hardware 3606. Processor(s) 3602 can be configured to implement one or more methods described herein. One or more memories 3604 can be used to store data and code used to implement the methods and techniques described herein. Video processing hardware 3606 can be used to implement some of the techniques described in this document in hardware circuitry.

[0638] Figure 10 is a block diagram illustrating an example video coding system 100 that may utilize the techniques of this disclosure.

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

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

[0641] The video source 112 may include a source such as a video capture device, an interface for receiving video data from a video content provider, and / or a computer graphics system for generating video data, or a combination of these sources. The video data may include one or more pictures. The video encoder 114 encodes the video data from the video source 112 to generate a bitstream. The bitstream may include a sequence of bits that form a codec representation of the video data. The bitstream may include a codec picture and associated data. The codec picture is a codec representation of the picture. The associated data may include a sequence parameter set, a picture parameter set, and other syntax structures. The I / O interface 116 may include a modulator / demodulator (modem) and / or a transmitter. The encoded video data may be sent directly to the destination device 120 via the network 130a via the I / O interface 116. The encoded video data may also be stored on a storage medium / server 130b for access by the destination device 120.

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

[0643] I / O interface 126 may include a receiver and / or a modem. I / O interface 126 may obtain 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 located external to destination device 120, with destination device 120 configured to interface with an external display device.

[0644] The video encoder 114 and the video decoder 124 may operate according to a video compression standard, such as the High Efficiency Video Codec (HEVC) standard, the Versatile Video Codec (VVM) standard, and other current and / or future standards.

[0645] Figure 11 is a block diagram illustrating an example of a video encoder 200, which may be Figure 10 The video encoder 114 in the system 100 is shown.

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

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

[0648] 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 a picture in which the current video block is located.

[0649] Furthermore, some components (e.g., motion estimation unit 204 and motion compensation unit 205) may be highly integrated, but for purposes of explanation, are not described in detail in the preceding text. Figure 11 In the examples, they are respectively represented.

[0650] The partitioning unit 201 may partition a picture into one or more video blocks. The video encoder 200 and the video decoder 300 may support various video block sizes.

[0651] The mode selection unit 203 can, for example, select one of the coding modes (intra or inter) based on the error result, and provide the resulting intra or inter coded block to the residual generation unit 207 to generate residual block data, and to the reconstruction unit 212 to reconstruct the coded block for use as a reference picture. In some examples, the mode selection unit 203 can select a combination of intra prediction and inter prediction (CIIP) modes, where the prediction is based on an inter prediction signal and an intra prediction signal. The mode selection unit 203 can also select the resolution of the motion vector for the block in the case of inter prediction (e.g., sub-pixel precision or integer pixel precision).

[0652] To perform inter-frame prediction on the current video block, the motion estimation unit 204 may generate motion information for the current video block by comparing the current video block with one or more reference frames from the buffer 213. The motion compensation unit 205 may determine a predicted video block for the current video block based on the motion information and decoded samples of pictures other than the picture associated with the current video block from the buffer 213.

[0653] For example, motion estimation unit 204 and motion compensation unit 205 may perform different operations on the current video block depending on whether the current video block is in an I slice, a P slice, or a B slice.

[0654] In some examples, motion estimation unit 204 may perform unidirectional prediction on the current video block, and motion estimation unit 204 may search for a reference video block for the current video block in the reference pictures in list 0 or list 1. Motion estimation unit 204 may then generate a reference index indicating the reference picture in list 0 or list 1 containing 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 may output the reference index, the prediction direction indicator, and the motion vector as motion information for the current video block. Motion compensation unit 205 may generate a predicted video block for the current block based on the reference video block indicated by the motion information for the current video block.

[0655] In other examples, the motion estimation unit 204 may perform bidirectional prediction on the current video block. The motion estimation unit 204 may search for a reference video block for the current video block in the reference pictures in list 0 and may also search for another reference video block for the current video block in the reference pictures in list 1. The motion estimation unit 204 may then generate reference indexes indicating the reference pictures in list 0 and list 1 containing the reference video block, and a motion vector indicating the spatial displacement between the reference video block and the current video block. The motion estimation unit 204 may output the reference index and motion vector for the current video block as motion information for the current video block. The motion compensation unit 205 may 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.

[0656] In some examples, motion estimation unit 204 may output a complete set of motion information for use in the decoding process of a decoder.

[0657] In some examples, motion estimation unit 204 may not output a complete set of motion information for the current video. Instead, motion estimation unit 204 may reference motion information of another video block to signal the motion information of the current 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 a neighboring video block.

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

[0659] In another example, the motion estimation unit 204 can identify another video block and a motion vector difference (MVD) in a 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 indicated video block. The video decoder 300 can use the motion vector of the indicated video block and the motion vector difference to determine the motion vector of the current video block.

[0660] As discussed above, the video encoder 200 may predictively signal motion vectors.Two examples of predictive signaling techniques that may be implemented by the video encoder 200 include advanced motion vector prediction (AMVP) and merge mode signaling.

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

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

[0663] In other examples, for the current video block, there may be no residual data of the current video block, for example, in skip mode, the residual generation unit 207 may not perform the subtraction operation.

[0664] Transform processing unit 208 may generate one or more transform coefficient video blocks for a current video block by applying one or more transforms to the residual video block associated with the current video block.

[0665] After transform processing unit 208 generates a transform coefficient video block associated with the current video block, quantization unit 209 may 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.

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

[0667] After the reconstruction unit 212 reconstructs the video block, a loop filtering operation may be performed to reduce video block artifacts in the video block.

[0668] The entropy coding unit 214 may receive data from other functional components of the video encoder 200. When the entropy coding unit 214 receives the data, the entropy coding unit 214 may perform one or more entropy coding operations to generate entropy-coded data and output a bitstream including the entropy-coded data.

[0669] Figure 12 is a block diagram illustrating an example of a video decoder 300, which may be Figure 10 The video decoder 114 in the system 100 is shown.

[0670] Video decoder 300 may be configured to perform any or all of the techniques of this disclosure. Figure 12 In the example of FIG, video decoder 300 includes multiple functional components. The techniques described in this disclosure can be shared among the various components of video decoder 300. In some examples, a processor can be configured to perform any or all of the techniques described in this disclosure.

[0671] exist Figure 12 In the example of FIG. 3 , the video decoder 300 includes an entropy decoding unit 301, a motion compensation unit 302, an intra 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 encoding passes generally similar to those described with respect to the video encoder 200 ( Figure 11 )The opposite decoding pass.

[0672] The entropy decoding unit 301 can retrieve a coded bitstream. The coded bitstream can include entropy-coded video data (e.g., coded blocks of video data). The entropy decoding unit 301 can decode the entropy-coded video data, and the motion compensation unit 302 can determine motion information based on the entropy-decoded video data, including motion vectors, motion vector precision, reference picture list index, and other motion information. For example, the motion compensation unit 302 can determine this information by performing AMVP and merge modes.

[0673] The motion compensation unit 302 may generate a motion compensated block, possibly performing interpolation based on an interpolation filter. An identifier of an interpolation filter to be used with sub-pixel precision may be included in the syntax element.

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

[0675] The motion compensation unit 302 may use some syntax information to determine the size of blocks used to encode frames and / or slices of the coded video sequence, partitioning information describing how each macroblock of a picture of the coded video sequence is partitioned, a mode indicating how each partition is to be encoded, one or more reference frames (and reference frame lists) to use for each inter-frame coded block, and other information used to decode the coded video sequence.

[0676] The intra prediction unit 303 can form a prediction block based on spatially adjacent blocks using, for example, an intra prediction mode received in the bitstream. The inverse quantization unit 303 inverse quantizes (i.e., dequantizes) the quantized video block coefficients provided in the bitstream and decoded by the entropy decoding unit 301. The inverse transform unit 303 applies an inverse transform.

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

[0678] A list of preferred solutions for some embodiments is provided below.

[0679] The following solution illustrates an example embodiment of the technique discussed in the previous section (eg, item 1).

[0680] 1. A video processing method (e.g., Figure 9 ), comprising: performing a conversion (902) between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures, the sub-picture comprising one or more slices, wherein the codec representation conforms to a format rule; wherein the format rule provides that, when rectangular slice mode is enabled for the video picture, a picture-level slice index for each slice in each sub-picture in the video picture is derived without explicit signaling in the codec representation; wherein the format rule provides that the number of codec tree units in each slice is derivable from the picture-level slice index.

[0681] The following solution illustrates an example embodiment of the technique discussed in the previous section (eg, item 2).

[0682] 2. A video processing method, comprising: performing conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures, each sub-picture comprising one or more strips, wherein the codec representation complies with format rules; wherein the format rules specify that a sub-picture level strip index can be derived based on information in the codec representation without the need for signaling the sub-picture level strip index in the codec representation.

[0683] 3. The method of solution 2, wherein the format rule stipulates that due to the use of a rectangular slice structure, the sub-picture level slice index corresponds to the index of the slice in the list of slices in the sub-picture.

[0684] 4. The method of solution 2, wherein the format rules specify that the sub-picture level slice index is derived from a specific value of the picture level slice index.

[0685] The following solutions illustrate example embodiments of the techniques discussed in the previous section (eg, items 5, 6).

[0686] 5. A video processing method, comprising: performing conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more sub-pictures and / or one or more slices, wherein the codec representation complies with format rules; wherein the conversion complies with constraint rules.

[0687] 6. The method of solution 5, wherein the constraint rule stipulates that a slice cannot be in more than one sub-picture.

[0688] 7. The method of solution 5, wherein the constraint rule stipulates that a sub-picture cannot include two slices that are smaller than the corresponding slice to which the two slices belong.

[0689] The following solutions illustrate example embodiments of the techniques discussed in the previous section (eg, items 7, 8).

[0690] 8. A video processing method, comprising: performing conversion between a video comprising one or more video pictures and a codec representation of the video, wherein each video picture comprises one or more slices and / or one or more strips; wherein the codec representation complies with format rules; wherein the format rules specify that fields at the video picture level carry information about the segmentation of strips and / or slices in the video picture.

[0691] 9. The method of solution 8, wherein the field includes a video picture header.

[0692] 10. The method of solution 8, wherein the field includes a picture parameter set.

[0693] 11. The method of any of solutions 8-10, wherein the format rule specifies omitting slice segmentation information at the slice level by including the slice segmentation information in a field at the video picture level.

[0694] The following solution illustrates an example embodiment of the technique discussed in the previous section (eg, item 9).

[0695] 12. A video processing method comprising: performing a conversion between a video comprising one or more pictures and a codec representation of the video, wherein the conversion complies with a segmentation rule that determines whether a minimum number of strips into which the video picture is segmented is determined based on whether rectangular segmentation is used to segment the video picture.

[0696] 13. The method of solution 12, wherein the segmentation rule specifies using at least two stripes for non-rectangular segmentation and at least one stripe for rectangular segmentation.

[0697] 14. The method of solution 12, wherein the segmentation rule is also a function of whether and / or how many sub-pictures are used to segment the video picture.

[0698] The following solutions illustrate example embodiments of the techniques discussed in the previous section (eg, items 10, 11).

[0699] 15. A video processing method, comprising: performing conversion between a video strip of a video area of ​​a video and a codec representation of the video; wherein the codec representation complies with a format rule; wherein the format rule stipulates that the codec representation signals the video strip based on the upper left position of the video strip, wherein the format rule stipulates that the codec representation signals the height and / or width of the video strip in segmentation information signaled at the video unit level.

[0700] 16. The method of solution 15, wherein the format rule dictates that the video slices are signaled in the order of the slices defined by the format rule.

[0701] 17. The method of solution 15, wherein the video region corresponds to a sub-picture, and wherein the video unit level corresponds to a video picture.

[0702] The following solution illustrates an example embodiment of the technique discussed in the previous section (eg, item 12).

[0703] 18. A video processing method comprising: performing conversion between a video including video pictures and a codec representation of the video; wherein the codec representation complies with a format rule; wherein the format rule dictates omitting signaling of a difference between a slice index of a first slice in a rectangular strip and a slice index of a first slice in a next rectangular strip.

[0704] 19. The method of solution 18, wherein the difference is derived from the zeroth strip and the rectangular strip in the video picture.

[0705] The following solution illustrates an example embodiment of the technique discussed in the previous section (eg, item 13).

[0706] 20. A video processing method comprising: performing conversion between a video and a codec representation of the video, wherein the codec representation conforms to a format rule, wherein the format rule specifies a relationship between a width of a video picture and a size of a codec tree unit to control signaling notification of information used to derive a number of slice columns or a number of slice rows in a video picture.

[0707] 21. The method of solution 20, wherein the format rule specifies excluding signaling the number of slice rows or the number of slice columns when the width of the video picture is less than or equal to the width of the codec tree unit.

[0708] The following solution shows an example embodiment of the technique discussed in the previous section (e.g., item 16).

[0709] 22. A video processing method comprising: performing conversion between a video comprising one or more video pictures and an encoded representation of the video, wherein the encoded representation complies with format rules, wherein the format rules specify including slice layout information in the encoded representation of the video pictures comprising evenly spaced slices and non-evenly spaced slices.

[0710] 23. The method of solution 22, wherein the slice layout information is included in a syntax flag contained in a picture parameter set.

[0711] 24. The method of any of solutions 22-23, wherein the number of tile rows or the number of tile columns explicitly signaled is not less than the number of non-uniformly spaced tiles.

[0712] 25. The method of any of solutions 22-23, wherein the number of tile rows or the number of tile columns explicitly signaled is not less than the number of evenly spaced tiles.

[0713] 26. The method of any of the above solutions, wherein the video area includes a video codec unit.

[0714] 27. The method of any of the above solutions, wherein the video area comprises a video picture.

[0715] 28. The method of any of solutions 1 to 27, wherein converting comprises encoding the video into a codec representation.

[0716] 29. The method of any of solutions 1 to 27, wherein converting comprises decoding the codec representation to generate pixel values ​​of the video.

[0717] 30. A video decoding device comprising a processor configured to implement the method described in one or more of solutions 1 to 29.

[0718] 31. A video encoding apparatus comprising a processor configured to implement the method described in one or more of solutions 1 to 29.

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

[0720] 33. A method, apparatus or system as described in this document.

[0721] Figure 131 is a flowchart representation of a video processing method 1300 according to the present technology. The method 1300 includes, at operation 1310, performing conversion between a video picture including one or more slices and one or more rectangular strips and a bitstream of the video according to a rule. The rule specifies that, to iteratively determine information about the one or more rectangular strips, a variable indicating a slice index is updated only for strips having an index less than a value equal to the number of rectangular strips in the video picture minus 1.

[0722] In some embodiments, a variable that determines information about the last rectangular slice in a video picture is not updated. In some embodiments, determining the information is performed using a picture parameter set referenced by the video picture. In some embodiments, one of the one or more rectangular slices has a slice index i, and the information includes at least one of: a slice index of a slice including a first codec tree unit in the slice, a width of the slice, or a height of the slice. In some embodiments, the information includes at least one of: a list of the number of codec tree units in the one or more rectangular slices, an upper left slice index of the one or more rectangular slices, or a picture raster scan address of a codec tree block within the slice. In some embodiments, updating the variable includes adding a difference between (1) a first slice index of a first slice including a first codec tree unit in a first slice having a slice index i+1 and (2) a second slice index of a second slice including a first codec tree unit in a second slice having a slice index i. In some embodiments, the variable is updated by adding (A-1)*B, where A indicates the height of the slice in slice rows and B indicates the number of slice columns of the video slice. In some embodiments, a first slice of the one or more slices includes at least one rectangular strip, and wherein the information of the at least one rectangular strip includes a height of each of the at least one rectangular strip.

[0723] Figure 14 14 is a flowchart representation of a video processing method 1400 according to the present technology. The method 1400 includes, at operation 1410, performing conversion between a video picture including one or more sub-pictures and a video bitstream. The conversion complies with a rule that omits syntax elements in a sequence parameter set that indicate the number of sub-pictures in a video picture if the maximum picture width and the maximum picture height are equal to or less than the dimensions of a codec treeblock.

[0724] Figure 15 1 is a flowchart representation of a video processing method 1500 according to the present technology. The method 1500 includes, at operation 1510, performing conversion between a video picture including one or more slices and a video bitstream. The conversion complies with a rule that omits a syntax element indicating the number of explicitly provided slice column widths in the bitstream if the width of the video picture is equal to or less than the dimension of the codec treeblock.

[0725] Figure 16 1 is a flowchart representation of a video processing method 1600 according to the present technology. The method 1600 includes, at operation 1610, performing conversion between a video picture including one or more slices and a video bitstream. The conversion complies with a rule that omits a syntax element indicating the number of explicitly provided slice row heights in the bitstream if the height of the video picture is equal to or less than the dimension of the codec treeblock.

[0726] In some embodiments, the dimension of the codec treeblock is indicated by the parameter CtbSizeY.In some embodiments, the number of sub-pictures in a video picture is inferred to be zero.

[0727] Figure 17 17 is a flowchart representation of a video processing method 1700 according to the present technology. The method 1700 includes, at operation 1710, performing conversion between a video picture including one or more slices and a video bitstream. The conversion complies with a rule that omits one or more syntax elements indicating the column widths of the one or more slices in the bitstream when the number of explicitly provided slice column widths is equal to the picture width in units of codec treeblocks. In some embodiments, the column width of the one or more slices is inferred to be zero.

[0728] Figure 18 18 is a flowchart representation of a video processing method 1800 according to the present technology. The method 1800 includes, at operation 1810, performing conversion between a video picture including one or more slices and a video bitstream. The conversion complies with a rule that omits one or more syntax elements indicating the row heights of one or more slices from the bitstream if the number of explicitly provided slice row heights is equal to the picture height in units of codec tree blocks. In some embodiments, the row heights of one or more slices are inferred to be zero.

[0729] Figure 19 1 is a flowchart representation of a video processing method 1900 according to the present technology. The method 1900 includes, at operation 1910, performing conversion between a video picture including one or more slices and a bitstream of the video. The conversion complies with rules that stipulate that slice segmentation information is included in the bitstream.

[0730] In some embodiments, the stripe segmentation information includes a stripe width of the one or more stripes. In some embodiments, the width of the stripe is indicated by the width of the stripe minus X, where X is a non-negative value. In some embodiments, X is equal to 1, and the width of the stripe is indicated by the variable slice_width_minus1[i]. i represents the stripe index of the stripe. In some embodiments, the stripe segmentation information includes a height of a stripe in the one or more stripes. In some embodiments, the height of the stripe is indicated by the height of the stripe minus X, where X is a non-negative value. In some embodiments, X is equal to 1, and the height of the stripe is indicated by the variable slice_height_minus1[i], where i represents the stripe index of the stripe.

[0731] In some embodiments, whether the slice segmentation information includes the top left position or dimensions of the slice is determined based on characteristics of the slice. In some embodiments, when a video picture includes one or more rectangular slices, the slice segmentation information includes the top left position or dimensions of the slice. In some embodiments, the characteristics of the slice include an index of the slice, a codec treeblock dimension associated with the slice, dimensions of a video picture including the slice, or the number of slices in the video picture.

[0732] In some embodiments, the video picture includes one or more sub-pictures, and whether the slice segmentation information includes a top-left position and dimensions of a slice is determined based on a relationship between a segmentation of the one or more slices and a segmentation of the one or more sub-pictures. In some embodiments, when at least one of the one or more sub-pictures includes more than one slice, the slice segmentation information includes a top-left position or dimensions of the slice.

[0733] In some embodiments, whether the slice segmentation information includes the upper left position or dimension of the slice is determined based on the number of slices in the video picture. In some embodiments, when the number of slices in the video picture is greater than 1, the slice segmentation information includes the upper left position or dimension of the slice to represent the slice. In some embodiments, the upper left position or dimension of at least one slice is expressed in units of codec tree unit dimensions or in units of slice dimensions. In some embodiments, a syntax element is used to convert to indicate whether the upper left position or dimension of at least one slice is expressed in units of codec tree unit dimensions or in units of slice dimensions. In some embodiments, the syntax element indicates whether the upper left position or dimension of each of the one or more slices is expressed in units of codec tree unit dimensions or in units of slice dimensions. In some embodiments, the syntax element is slice_represented_in_ctb_flag[i], where i represents the index of the slice.

[0734] In some embodiments, at least one of the top left position or dimension of the slice is omitted in the slice segmentation information, and the top left position or dimension of the slice is inferred as a default value. In some embodiments, the default value for the top left position of the slice includes (0, 0). In some embodiments, the default value for the dimension of the slice is based on the syntax element slice_represented_in_ctb_flag[i], where i represents the index of the slice. In some embodiments, the default value for the slice width is equal to (slice_represented_in_ctb_flag[i]?((pic_width_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY):NumTileColumns)-slice_top_left_x[i]–1. In some embodiments, the default value of the slice height is equal to (slice_represented_in_ctb_flag[i]?((pic_height_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY):NumTileRows)-slice_top_left_y[i]–1.

[0735] Figure 20 2 is a flowchart representation of a video processing method 2000 according to the present technology. The method 2000 includes, at operation 2010, performing conversion between a video slice including one or more rectangular slices and a video bitstream according to a rule. The rule specifies determining uniform slice heights based on a first syntax element and a second syntax element, wherein the first syntax element specifies the height of the rectangular slices in units of codec tree unit rows in the video slice and the second syntax element specifies the number of slice heights explicitly provided in the video slice.

[0736] In some embodiments, the first syntax element is exp_slice_height_in_ctus_minus1[i] and the second syntax element is num_exp_slices_in_tile[i], where i is the index of the rectangular slice, and where the uniform slice height is based on exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1]. In some embodiments, the num_exp_slices_in_tile[i]-1th non-uniform slice height is based on exp_slice_height_in_ctus_minus1[i][num_exp_slices_in_tile[i]-1].

[0737] Figure 212 is a flowchart representation of a video processing method 2100 according to the present technology. The method 2100 includes, at operation 2110, performing conversion between a video picture including one or more slices and a video bitstream according to a rule. The rule specifies that a syntax element is equal to or greater than a dimension of a uniform slice column or uniform slice row, wherein the syntax element indicates a dimension in units of a codec treeblock, excluding a total dimension of a plurality of explicitly provided slice column widths or a plurality of explicitly provided slice row heights.

[0738] In some embodiments, the syntax element is firstRemainingWidthInCtbsY. In some embodiments, the syntax element is firstRemainingHeightInCtbsY.

[0739] Figure 22 2 is a flowchart representation of a video processing method 2200 according to the present technology. The method 2200 includes, at operation 2210, performing conversion between a video slice including one or more slices and a video bitstream according to a rule. The rule specifies that a syntax element is equal to or greater than a uniform slice height, wherein the syntax element indicates a height in units of codec tree blocks, excluding a total height of multiple explicitly provided slice heights.

[0740] Figure 23 2 is a flowchart representation of a video processing method 2300 according to the present technology. The method 2300 includes, at operation 2310, performing conversion between a video and a bitstream of the video according to a rule. The rule specifies using a syntax element for the conversion to indicate a maximum number of affine merge candidates allowed in a sub-block-based merge candidate list.

[0741] In some embodiments, whether the syntax element is signaled for a conversion is based on whether the affine prediction tool is enabled. In some embodiments, when the syntax element is omitted in the bitstream, the syntax element is inferred to have a default value such that the maximum number of affine merge candidates allowed in the sub-block based merge candidate list is 0. In some embodiments, the maximum number of affine merge candidates allowed in the sub-block based merge candidate list is equal to the difference between five and the syntax element. In some embodiments, the syntax element is in the range [0, X] (inclusive), where X is an integer. In some embodiments, X is 5.

[0742] In some embodiments, where the syntax element is omitted in the bitstream, the syntax element is inferred to be 5. In some embodiments, the maximum number of affine merge candidates allowed in the sub-block based merge candidate list is determined based on the syntax element and the maximum number of allowed sub-block based temporal motion vector prediction (TMVP) merge candidates. In some embodiments, the maximum number of affine merge candidates allowed in the sub-block based merge candidate list is equal to Min(5, (sps_sbtmvp_enabled_flag && ph_temporal_mvp_enable_flag) + 5 - five_minus_max_num_affine_merge_cand), where five_minus_max_num_affine_merge_cand is a syntax element.

[0743] In some embodiments, converting includes encoding the video into a bitstream. In some embodiments, converting includes decoding the video from the bitstream.

[0744] In the solution described herein, an encoder can conform to the format rules by generating a codec representation according to the format rules. In the solution described herein, a decoder can use the format rules to parse syntax elements in the codec representation and understand the presence and absence of syntax elements according to the format rules to produce decoded video.

[0745] In this document, the term "video processing" may refer to video encoding, video decoding, video compression, or video decompression. For example, during conversion from a pixel representation of a video to a corresponding bitstream, a video compression algorithm may be applied, or vice versa. The bitstream for a current video block may, for example, correspond to bits that are juxtaposed or interspersed at different locations within the bitstream, as defined by the syntax. For example, a macroblock may be encoded based on a transformed and encoded error residual, and also using bits from a header and other fields in the bitstream. Furthermore, during conversion, a decoder may parse the bitstream knowing that some fields may or may not be present, based on determinations as described in the above solution. Similarly, an encoder may determine whether to include or not include certain syntax fields, and generate the codec representation accordingly by including or excluding the syntax fields from the codec representation.

[0746] The disclosed solutions and other solutions, examples, embodiments, modules, and functional operations described in this document may be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this document and their structural equivalents, or any combination thereof. The disclosed embodiments and other embodiments may be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer-readable medium for execution by or to control the operation of a data processing apparatus. The computer-readable medium may be a machine-readable storage device, a machine-readable storage substrate, a memory device, a composition of matter that effects a machine-readable propagated signal, or one or more combinations thereof. The term "data processing apparatus" encompasses all devices, equipment, 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 any combination thereof. A propagated signal is an artificially generated signal, such as a machine-generated electrical, optical, or electromagnetic signal, that is generated to encode information for transmission to a suitable receiver device.

[0747] A computer program (also referred to as a program, software, software application, script, or code) can be written in any form of programming language, including compiled or interpreted languages, and can also be deployed in any form, including as a standalone program or a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a file portion that holds other programs or data (e.g., one or more scripts stored in a markup language document), a single file dedicated to the relevant program, or multiple coordinated files (e.g., files that store one or more modules, subroutines, or code portions). A computer program can be deployed to execute on a single computer, or on multiple computers located at one site or distributed across multiple sites and interconnected by a communications network.

[0748] 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 operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus can also be implemented as, special purpose logic circuitry, such as an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit).

[0749] For example, processors suitable for executing computer programs include general-purpose and special-purpose microprocessors, as well as any one or more processors of any type of digital computer. Typically, a processor will receive instructions and data from read-only memory or random access memory, or both. The essential elements 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 or be operatively coupled to receive data from or transfer data to one or more mass storage devices for storing data (e.g., magnetic disks, magneto-optical disks, or optical disks). However, a computer does not require such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and storage devices, including, for example, semiconductor memory devices such as EPROM, EEPROM, and flash memory devices; magnetic disks, such as internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and memory may be supplemented by or incorporated into dedicated logic circuitry.

[0750] Although this patent document contains many details, these details should not be interpreted as limitations on the scope of any subject matter or claimed content, but rather as descriptions of features unique to specific embodiments of specific technologies. Certain features described in this patent document in the context of separate embodiments may also be implemented in combination in a single embodiment. Conversely, the various features described in the context of a single embodiment may also be implemented in multiple embodiments individually or in any suitable subcombination. In addition, although the above-mentioned features may be described as working in a particular combination, or even initially claimed to be so, in some cases, one or more features may be deleted from the claimed combination, and the claimed combination may refer to a subcombination or a variant of a subcombination.

[0751] Similarly, while operations are depicted in a particular order in the accompanying drawings, this should not be understood as requiring that such operations be performed in the particular order or sequential order shown, or that all illustrated operations be performed, in order to achieve desired results. Furthermore, the separation of various system components in the embodiments described in this patent document should not be understood as requiring such separation in all embodiments.

[0752] Only a few implementations and examples are described, and other implementations, enhancements, and variations can be made based on what is described and illustrated in this patent document.

Claims

1. A method for processing video data, comprising: For conversion between a video comprising a video picture and a bitstream of the video, determining that a scanning process is applied to the video picture, wherein the video picture is partitioned into one or more slices, one or more slices, and a plurality of codec tree units, In the scanning process, when a rectangular slice mode is used for the video picture, determining that a variable indicating a slice index of a slice of a first codec tree unit in a slice having a picture-level slice index is updated when the picture-level slice index is less than a value of a first syntax element, and that the variable is not updated when the picture-level slice index is not less than the value of the first syntax element; and performing said converting based on said determining, The first syntax element is included in a picture parameter set referenced by the video picture in the bitstream, is for deriving information about one or more slices in the video picture, and the number of slices in the video picture is greater than a value of the first syntax element; wherein, for a slice having a first slice index of a plurality of rectangular slices, determining that a fourth syntax element is included in the bitstream to indicate a number of explicitly provided slice heights of slices in a video slice containing the rectangular slice having the first slice index, wherein the number of explicitly provided slice heights of slices in the video slice is equal to N, and N is an integer not less than 0, When N is not less than 1, when a first difference between the height of the video slice in units of codec tree blocks and the sum of the slice heights of the N slices is less than a uniform slice height, the slice height of the (N+1)th slice of the video slice is set to the first difference.

2. The method according to claim 1, wherein for a first slice having a picture-level slice index smaller than a value of the first syntax element, when the slice including the first slice is not partitioned into a plurality of slices, deriving a width of the first slice in units of slice columns from a second syntax element corresponding to the first slice in the picture parameter set, and deriving a height of the first slice in units of slice rows from a third syntax element corresponding to the first slice in the picture parameter set, and wherein, for a second slice having a picture-level slice index not less than the value of the first syntax element, a width of the second slice in units of slice columns is derived from a difference between the number of slice columns and tileX, and a height of the second slice in units of slice rows is derived from the number of slice rows and tileY, Wherein, tileX and tileY are determined based on the number of tile columns.

3. The method according to claim 1, wherein The slice has a picture-level slice index i, where i is an integer, and Wherein, updating the variable comprises adding a second difference between a first slice index of a first slice including the first codec tree unit in a slice having an index i+1 and a slice index of the slice including the first codec tree unit in the slice having the index i.

4. The method according to claim 3, wherein: The second difference value is specified by a second syntax element included in the picture parameter set of the slice, Wherein, when the index i is not less than the value of the first syntax element, the second syntax element does not exist in the picture parameter set of the slice with the index i, and In which, in response to the second syntax element being present in the picture parameter set, updating the variable includes adding the second difference value.

5. The method according to claim 4, wherein When the second syntax element is not present in the picture parameter set, updating the variable comprises adding a width of the slice with the index i, and wherein the width is expressed in units of slice columns.

6. The method according to claim 5, wherein: When tileIdx % B is equal to 0, updating the variable includes adding (A-1)*B, Wherein, tileIdx represents the variable, where A is the height of the stripe with index i in units of slice rows, Where B is the number of slice columns in the video picture, and Among them, % represents the remainder operator.

7. The method according to claim 1, wherein When the value of the first syntax element is greater than 0, the width and height of the slice are specified by one or more syntax elements included in the bitstream.

8. The method according to claim 7, wherein: The width of the slice is expressed in units of slice columns, and for a second slice having a picture-level slice index not less than a value of the first syntax element, the height of the second slice is expressed in units of slice rows.

9. The method according to claim 1, wherein The value of the first syntax element plus 1 specifies the number of rectangular slices in the video picture.

10. The method according to claim 1, wherein The converting includes encoding the video into the bitstream.

11. The method according to claim 1, wherein The converting includes decoding the video from the bitstream.

12. An apparatus for processing video data, comprising a processor and a non-transitory memory having instructions thereon, wherein: The instructions, when executed by the processor, cause the processor to: For conversion between a video comprising a video picture and a bitstream of the video, determining that a scanning process is applied to the video picture, wherein the video picture is partitioned into one or more slices, one or more slices, and a plurality of codec tree units, In the scanning process, when a rectangular slice mode is used for the video picture, determining that a variable indicating a slice index of a slice of a first codec tree unit in a slice having a picture-level slice index is updated when the picture-level slice index is less than a value of a first syntax element, and is not updated when the picture-level slice index is not less than the value of the first syntax element; and performing said converting based on said determining, The first syntax element is included in a picture parameter set referenced by the video picture in the bitstream, is for deriving information about one or more slices in the video picture, and the number of slices in the video picture is greater than a value of the first syntax element; wherein, for a slice having a first slice index of a plurality of rectangular slices, determining that a fourth syntax element is included in the bitstream to indicate a number of explicitly provided slice heights of slices in a video slice containing the rectangular slice having the first slice index, wherein the number of explicitly provided slice heights of slices in the video slice is equal to N, and N is an integer not less than 0, When N is not less than 1, when a first difference between the height of the video slice in units of codec tree blocks and the sum of the slice heights of the N slices is less than a uniform slice height, the slice height of the (N+1)th slice of the video slice is set to the first difference.

13. The apparatus according to claim 12, wherein: for a first slice having a picture-level slice index smaller than a value of the first syntax element, when the slice including the first slice is not partitioned into a plurality of slices, deriving a width of the first slice in units of slice columns from a second syntax element corresponding to the first slice in the picture parameter set, and deriving a height of the first slice in units of slice rows from a third syntax element corresponding to the first slice in the picture parameter set, and wherein, for a second slice having a picture-level slice index not less than the value of the first syntax element, a width of the second slice in units of slice columns is derived from a difference between the number of slice columns and tileX, and a height of the second slice in units of slice rows is derived from the number of slice rows and tileY, Wherein, tileX and tileY are determined based on the number of tile columns.

14. The device according to claim 12, wherein The slice has a picture-level slice index i, where i is an integer, and Wherein, updating the variable comprises adding a second difference between a first slice index of a first slice including the first codec tree unit in a slice having an index i+1 and a slice index of the slice including the first codec tree unit in the slice having the index i.

15. The device according to claim 14, wherein The second difference value is specified by a second syntax element included in the picture parameter set of the slice, Wherein, when the index i is not less than the value of the first syntax element, the second syntax element does not exist in the picture parameter set of the slice with the index i, and In which, in response to the second syntax element being present in the picture parameter set, updating the variable includes adding the second difference value.

16. The device according to claim 15, wherein When the second syntax element is not present in the picture parameter set, updating the variable comprises adding a width of the slice with the index i, and wherein the width is expressed in units of slice columns.

17. A non-transitory computer-readable storage medium storing instructions that cause a processor to: For conversion between a video comprising video pictures and a bitstream of said video, determining that a scanning process is applied to said video pictures, wherein The video picture is divided into one or more slices, one or more strips and multiple codec tree units. In the scanning process, when a rectangular slice mode is used for the video picture, determining that a variable indicating a slice index of a slice of a first codec tree unit in a slice having a picture-level slice index is updated when the picture-level slice index is less than a value of a first syntax element, and that the variable is not updated when the picture-level slice index is not less than the value of the first syntax element; as well as performing said converting based on said determining, The first syntax element is included in a picture parameter set referenced by the video picture in the bitstream, is for deriving information about one or more slices in the video picture, and the number of slices in the video picture is greater than a value of the first syntax element; wherein, for a slice having a first slice index of a plurality of rectangular slices, determining that a fourth syntax element is included in the bitstream to indicate a number of explicitly provided slice heights of slices in a video slice containing the rectangular slice having the first slice index, wherein the number of explicitly provided slice heights of slices in the video slice is equal to N, and N is an integer not less than 0, When N is not less than 1, when the difference between the height of the video slice in units of codec tree blocks and the sum of the slice heights of the N slices is less than a uniform slice height, the slice height of the (N+1)th slice of the video slice is set to the difference.

18. The non-transitory computer-readable storage medium of claim 17, wherein: for a first slice having a picture-level slice index smaller than a value of the first syntax element, when the slice including the first slice is not partitioned into a plurality of slices, deriving a width of the first slice in units of slice columns from a second syntax element corresponding to the first slice in the picture parameter set, and deriving a height of the first slice in units of slice rows from a third syntax element corresponding to the first slice in the picture parameter set, and wherein, for a second slice having a picture-level slice index not less than the value of the first syntax element, a width of the second slice in units of slice columns is derived from a difference between the number of slice columns and tileX, and a height of the second slice in units of slice rows is derived from the number of slice rows and tileY, Wherein, tileX and tileY are determined based on the number of tile columns.

19. A non-transitory computer-readable storage medium storing a bitstream of a video generated by a method executed by a video processing device, wherein: The method comprises: For a video comprising a video picture, determining that a scanning process is applied to the video picture, wherein the video picture is partitioned into one or more slices, one or more strips, and a plurality of codec tree units, In the scanning process, when a rectangular slice mode is used for the video picture, determining that a variable indicating a slice index of a slice of a first codec tree unit in a slice having a picture-level slice index is updated when the picture-level slice index is less than a value of a first syntax element, and that the variable is not updated when the picture-level slice index is not less than the value of the first syntax element; and generating the bitstream based on the determination, The first syntax element is included in a picture parameter set referenced by the video picture in the bitstream, is for deriving information about one or more slices in the video picture, and the number of slices in the video picture is greater than a value of the first syntax element; wherein, for a slice having a first slice index of a plurality of rectangular slices, determining that a fourth syntax element is included in the bitstream to indicate a number of explicitly provided slice heights of slices in a video slice containing the rectangular slice having the first slice index, wherein the number of explicitly provided slice heights of slices in the video slice is equal to N, and N is an integer not less than 0, When N is not less than 1, when the difference between the height of the video slice in units of codec tree blocks and the sum of the slice heights of the N slices is less than a uniform slice height, the slice height of the (N+1)th slice of the video slice is set to the difference.

20. The non-transitory computer-readable storage medium of claim 19, wherein: for a first slice having a picture-level slice index smaller than a value of the first syntax element, when the slice including the first slice is not partitioned into a plurality of slices, deriving a width of the first slice in units of slice columns from a second syntax element corresponding to the first slice in the picture parameter set, and deriving a height of the first slice in units of slice rows from a third syntax element corresponding to the first slice in the picture parameter set, and wherein, for a second slice having a picture-level slice index not less than the value of the first syntax element, a width of the second slice in units of slice columns is derived from a difference between the number of slice columns and tileX, and a height of the second slice in units of slice rows is derived from the number of slice rows and tileY, Wherein, tileX and tileY are determined based on the number of tile columns.

21. A method for storing a video bitstream, comprising: For a video comprising a video picture, determining that a scanning process is applied to the video picture, wherein the video picture is partitioned into one or more slices, one or more strips, and a plurality of codec tree units, In the scanning process, when a rectangular slice mode is used for the video picture, determining that a variable indicating a slice index of a slice of a first codec tree unit in a slice having a picture-level slice index is updated when the picture-level slice index is less than a value of a first syntax element, and that the variable is not updated when the picture-level slice index is not less than the value of the first syntax element; generating the bitstream based on the determination, and storing the bitstream in a non-transitory computer-readable storage medium; The first syntax element is included in a picture parameter set referenced by the video picture in the bitstream, is for deriving information about one or more slices in the video picture, and the number of slices in the video picture is greater than a value of the first syntax element; wherein, for a slice having a first slice index of a plurality of rectangular slices, determining that a fourth syntax element is included in the bitstream to indicate a number of explicitly provided slice heights of slices in a video slice containing the rectangular slice having the first slice index, wherein the number of explicitly provided slice heights of slices in the video slice is equal to N, and N is an integer not less than 0, When N is not less than 1, when the difference between the height of the video slice in units of codec tree blocks and the sum of the slice heights of the N slices is less than a uniform slice height, the slice height of the (N+1)th slice of the video slice is set to the difference.

Images