Slice and tile partitioning in video coding

Abstract

To provide a video data processing method and a device for improving the transmission efficiency of tile division information.SOLUTION: The video data processing method includes performing a conversion between a video containing at least one video tile and a video bitstream according to a rule. The rule stipulates deriving the height of a slice in a video tile in units of coding tree units on the basis of a value of a first syntax element in the bitstream indicating the number of slice heights explicitly provided for the slice of the video tile containing that slice.SELECTED DRAWING: Figure 28

Description

[Technical Field]

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This application is a divisional application of Japanese Patent Application No. 2022-549960, which is the national stage of International Patent Application No. PCT / CN2021 / 077215, filed on February 22, 2021. The priority and benefit of international patent application PCT / CN2020 / 076158, filed on February 21, 2020, is timely claimed. All of the foregoing patent applications are incorporated herein by reference in their entirety.

[0002] This patent specification relates to image and video encoding and decoding. [Background technology]

[0003] Digital video is the largest bandwidth used on the Internet and other digital communication networks. The number of connected users who can receive and display video is used. As the number of devices increases, the bandwidth demands for digital video usage will continue to grow. is predicted. Summary of the Invention

[0004] This application provides a method for controlling the coding of video with control information useful for decoding the coded representation. Techniques that can be used in video encoders and decoders to process encoded representations Disclose.

[0005] In one exemplary embodiment, a video processing method is disclosed, the method comprising: , including converting between video pictures and video bitstreams. A video picture comprises one or more slices, and this rule states that at least one condition is met. In response to this, a syntax element indicating the difference in tile indices of the two rectangular slices is The first of two rectangular slices is specified as a , the i-th rectangular slice, where i is an integer.

[0006] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. An image picture comprises one or more sub-pictures, each of which is made up of one or more rectangular slides. This rule provides a subpicture layer for each rectangular slice in each subpicture. The slice index is derived for each slice, and the coding tree unit for each slice is calculated. This specifies that the number of

[0007] In another exemplary aspect, a video processing method is disclosed. The method comprises: For conversion between video pictures of a video comprising pictures and a bitstream of this video, Subpicture level slice index of the slice in the subpicture and this slice This includes determining a mapping relationship between the picture-level slice index and the picture-level slice index. The method also includes performing a transformation based on the determination.

[0008] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. A video picture comprises one or more sub-pictures, and this rule states that one tile of the video Specifies that the image is located entirely within one sub-picture of the video picture.

[0009] In another exemplary aspect, a video processing method is disclosed. The method comprises: and converting the video picture to a bitstream of the video picture. The bitstream comprises one or more sub-pictures. It complies with format rules that stipulate that the image contains information that divides the picture.

[0010] In another exemplary aspect, a method for processing an image is disclosed. A video picture of a video having one or more slices corresponding to the video picture and a bitstream of the video For the conversion, the method includes determining slice division information for the video picture. , and performing a transformation based on the determination.

[0011] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: Converting between a video picture of a video having one or more slices and a bitstream of this video This rule includes determining whether the number of slices in a video picture is greater than the number of slices in a video picture that fit within a rectangular area. At least the minimum number of slices, determined based on whether to apply partitioning or non-rectangular partitioning It is stipulated that:

[0012] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. A video picture comprises one or more slices. The slice division information of a video picture is When included in a unit syntax construct, a slice is represented by its top-left position and the dimensions of the slice. will be done.

[0013] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. An image picture comprises one or more sub-pictures, each of which comprises one or more slices. This rule specifies that the division information of one or more slices in each subpicture is divided into bits. Specifies how the stream exists.

[0014] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. An image picture comprises one or more rectangular slices, each of which comprises one or more tiles. This rule is defined as the first tile index of the first tile in the i-th rectangular slice. , the difference between the second tile index of the first tile in the (i+1)th rectangular slice is Specifies that it is not signaled in the bitstream.

[0015] In another exemplary aspect, a video processing method is disclosed. The method comprises: For conversion between the image and video bitstreams, the number of columns of tiles in a video picture and The information for deriving the number of rows and tiles is given by the video picture dimensions and coding tree blocks. conditionally included in the bitstream based on the relationship between the block dimensions The method also includes performing a transformation based on the determination.

[0016] In another exemplary aspect, a video processing method is disclosed. The method comprises: This involves converting between a picture and a video bitstream. This bitstream conforms to the format rules and contains one or more subpictures. In the bitstream, a subpicture identifier of a subpicture containing one slice is defined. If a variable exists that specifies the second variable corresponding to this syntax element, the second variable is considered to be equal to this variable. Specifies that there is exactly one syntax element that satisfies the condition.

[0017] In another exemplary aspect, a video processing method is disclosed. The method comprises: This involves converting between a picture and a video bitstream. It has one or more sub-pictures. Is non-rectangular division applied in the bitstream? Or, if subpicture information is omitted, two tiles in one slice are different. It has an address.

[0018] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. An image picture comprises one or more tiles. This rule requires that the tiles are evenly spaced. When organized with both uniform and uneven spacing, a single syntax element is used to create a tile layout. This specifies that the type of

[0019] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: This includes converting between video pictures and video bitstreams. The rule is that the merge estimation region , MER) is handled as the minimum allowable code. This specifies that the bit rate depends on the bit rate block size.

[0020] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: Converting a video having at least one video tile and a bitstream of the video This rule specifies the slicing in the video tiles in units of coding tree units. The height of a slice is specified by the slice provided explicitly for the slice in the video tile that contains it. It specifies that the value of the first syntax element in the bitstream indicates the number of bits per second. do.

[0021] In another exemplary aspect, a video processing method is disclosed, the method comprising the steps of: a video comprising a video picture comprising video tiles each comprising one or more slices; This rule involves converting the first slice in a picture to the bitstream. The height of the second slice in the tile containing The first slice has a first slice index, and the second slice has a The slices are the first slice index and the slice height provided explicitly in the video tile. The second slice index is determined based on the number of first slice indices. The height of the second slice is determined based on the second slice index and the second slice index.

[0022] In another exemplary aspect, a video processing method is disclosed. The video includes a video picture including a bitstream of the video. This video picture refers to a picture parameter set, and this picture parameter Set indicates that this picture parameter set contains a list of column widths for N tile columns. According to the format rules specified, where N is an integer, the video picture has (N The (N-1)th tile column exists and the width of the (N-1)th tile column is The (N-1)th coding tree block in the list is the width of the coding tree block plus one coding tree block. Equals entry.

[0023] In another exemplary aspect, a video processing method is disclosed. The video includes a video picture including a bitstream of the video. This video picture refers to a picture parameter set, and this picture parameter Set indicates that this picture parameter set contains a list of row heights for N tile rows. where N is an integer. There exists a (N-1)th tile row, and the height of this (N-1)th tile row is explicitly inclusive. The height of the tile row plus one coding tree block in the list (N- Equals the 1)th entry.

[0024] In another exemplary aspect, a video processing method is disclosed. The method comprises: converting between a video containing pictures and a coded representation of the video, A picture contains one or more subpictures, each of which contains one or more slices, and is coded as The representation conforms to formatting rules, which define rectangular areas for video pictures. When slice mode is enabled, each slice of each sub-picture in the video picture The picture-level slice index of a slice is a distinct slice in the coded representation. It specifies that the coding tree unit in each slice is derived without signaling. It specifies that the number of units is derivable from the picture-level slice index.

[0025] In another exemplary aspect, another video processing method is disclosed. The method comprises: converting between video, including video pictures, and coded representations of video; A video picture contains one or more sub-pictures, each containing one or more slices, and is coded. The coded representation follows formatting rules, which are then used to The sub-picture level slice index is not signaled for the current The sub-picture level slice index can be derived based on information in the representation. It stipulates that there is something.

[0026] In another exemplary aspect, another video processing method is disclosed. The method comprises: a video comprising video pictures, each video picture being made up of one or more sub-pictures and / or A video containing one or more tiles and a coded representation that complies with the format rules. This includes making constraint-rule-compliant transformations between

[0027] In another exemplary aspect, another video processing method is disclosed. The method comprises: converting between video including video pictures, each video picture being one or more time-domain The coded representation may include a rule and / or one or more slices, and the coded representation may be coded according to formatting rules The format rule is that video picture level fields are This specification specifies that the JPEG 2000 standard conveys information about the division of slices and / or tiles in a JPEG 2000 frame.

[0028] In another exemplary aspect, another video processing method is disclosed. The method comprises: converting between a video containing pictures and a coded representation of the video, The transformation is performed by dividing a video picture into a minimum number of slices. The partitioning rules are a function of whether or not rectangular partitioning is used.

[0029] In another exemplary aspect, another image processing method is disclosed. converting between a video slice of a region and a coded representation of the video; The representation conforms to formatting rules, which are then used to represent the specifying that the representation signals a video slice based on a top-left position of the video slice; The formatting rules are based on the fact that coded representations are signaled at the video unit level. It provides for signaling the height and / or width of the video slice in the slice information.

[0030] In another exemplary aspect, another video processing method is disclosed. The method comprises: converting between video containing the image and a coded representation of the video, The coded representation follows formatting rules, which are The tile index of the first tile in the slice and the first tile in the next rectangular slice. This specifies that different signaling between tile indices is omitted.

[0031] In another exemplary aspect, another image processing method is disclosed. converting the video to and from a coded representation of the video; conforms to formatting rules, which specify the width and coding of the video picture. Depending on the size of the Rendering Tree Unit, the columns or rows of tiles in this video picture specifies control over the signaling of information used to derive the number of rows.

[0032] In another exemplary aspect, another video processing method is disclosed. The method comprises: converting between video including video pictures and a coded representation of the video; ,This coded representation conforms to the formatting rules, which are , coding for video pictures containing uniformly and non-uniformly spaced tiles This specifies that the tagged representation includes tile layout information.

[0033] In yet another exemplary aspect, a video encoder apparatus is disclosed. The reader comprises a processor configured to implement the above-described method.

[0034] In yet another exemplary aspect, a video decoder apparatus is disclosed. comprises a processor configured to implement the above-described method.

[0035] In yet another exemplary aspect, a computer-readable medium having code stored thereon is disclosed. This code may be in the form of processor-executable code for performing one of the methods described herein. implement.

[0036] These and other features are described throughout this document. [Brief explanation of the drawings]

[0037] [Figure 1] An example of raster scan slice partitioning of a picture is shown, where the picture is divided into 12 tiles and 3 raster scan slices. [Figure 2] An example of rectangular slice partitioning of a picture is shown, where the picture is divided into 24 tiles (6 tile columns and 4 tile rows) and 9 rectangular slices. [Figure 3] An example of a picture divided into tiles and rectangular slices is shown, where the picture is divided into four tiles (two tile columns and two tile rows) and four rectangular slices. [Figure 4] A picture is shown divided into 15 tiles, 24 slices, and 24 sub-pictures. [Figure 5] Indicates the nominal vertical and horizontal positions of the 4:2:2 luma and chroma samples in the picture. [Figure 6] An example of picture division is shown. Blue lines represent tile boundaries, green lines represent slice boundaries, and red dashed lines represent sub-picture boundaries. The figure shows picture-level indices, decoding order indices, sub-picture-level indices, and sub-picture and tile indices for four slices. [Figure 7] FIG. 1 is a block diagram illustrating an example of a video processing system. [Figure 8] FIG. 1 is a block diagram of a video processing device. [Figure 9] 1 is a flowchart illustrating an example of a video processing method. [Figure 10] 1 is a block diagram illustrating a video coding system according to some embodiments of the present disclosure. [Figure 11] 1 is a block diagram illustrating an encoder according to some embodiments of the present invention. [Figure 12] FIG. 2 is a block diagram illustrating a decoder according to some embodiments of the present invention. [Figure 13] 1 is a flowchart illustrating a video processing method according to the present technology. [Figure 14] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 15] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 16] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 17] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 18] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 19] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 20] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 21] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 22] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 23] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 24] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 25] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 26] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 27] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 28] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 29] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 30] 10 is a flowchart illustrating another video processing method according to the present technology. [Figure 31] 10 is a flowchart illustrating another video processing method according to the present technology. DETAILED DESCRIPTION OF THE INVENTION

[0038] This specification uses section headings to facilitate understanding, and the technology and each The applicability of an embodiment described in a section is not limited to that section alone. The term .266 is used in some descriptions only for ease of understanding and disclosure. It is not intended to limit the scope of the technology described herein. The techniques disclosed are also applicable to other video codec protocols and designs.

[0039] 1. Overview This specification relates to video coding techniques, particularly subpicture, tile, and This idea is relevant to multi-level signaling, either individually or in various combinations. Ear video coding, such as the Versatile Video currently being developed Any video coding standard or non-standard video coding that supports VVC It may be applied to the deck.

[0040] 2. Abbreviations APS (Adaptation Parameter Set) to AU (Access Unit) AUD (Access Unit Delimiter) - AVC (Advanced Video Coding) CLVS (Coded Layer Video Sequence) coding Layered Video Sequence CPB (Coded Picture Buffer) A CRA (Clean Random Access) CTU (Coding Tree Unit) CVS (Coded Video Sequence) DPB (Decoded Picture Buffer) DPS (Decoding Parameter Set) EOB (End Of Bitstream) EOS (End Of Sequence) End of sequence GDR (Gradual Decoding Refresh) Gradual decoding refresh Shu HEVC (High Efficiency Video Coding) Image coding HRD (Hypothetical Reference Decoder) Virtual reference Decoder IDR (Instantaneous Decoding Refresh) No. Refresh JEM (Joint Exploration Model) MCTS (Motion-Constrained Tile Sets) Tile Set NAL (Network Abstraction Layer) Layer OLS (Output Layer Set) PH (Picture Header) PPS (Picture Parameter Set) PTL (Profile, Tier and Level) Call and Level PU (Picture Unit) RBSP (Raw Byte Sequence Payload) Sense Payload SEI (Supplemental Enhancement Information) n) Supplemental Enhancement Information SPS (Sequence Parameter Set) tt SVC (Scalable Video Coding) ng VCL (Video Coding Layer) VPS (Video Parameter Set) VTM (VVC Test Model) VUI (Video Usability Information) Security Information VVC (Versatile Video Coding) General-purpose video coding

[0041] 3. Initial consultations Video coding standards are primarily developed through the well-known ITU-T and ISO / IEC standards. ITU-T created H.261 and H.263, and ISO / IEC developed MP EG-1 and MPEG-4 Visual, and both organizations are H.262 / MPEG-2 V ideo and H.264 / MPEG-4 AVC (Advanced Video Cod) ing) and co-created the H.265 / HEVC standard. The standard uses a hybrid video coding structure that utilizes temporal prediction and transform coding. In 2015, to explore future video coding technologies beyond HEVC, is a joint project of VCEG and MPEG called JVET (Joint Video Exploration Since then, many new methods have been adopted by JVET. The reference software is called JEM (Joint Exploration Model). JVET meets quarterly to develop new coding standards. aims to reduce the bitrate by 50% compared to HEVC. At the T conference, a new video coding standard was introduced, called Versati At that time, the first edition of VVC technology was officially named VVC (Vide Video Coding). The VVC Standard Model (VTM) has been released. Efforts to contribute to the standardization of VVC are ongoing. Therefore, at every JVET meeting, new coding techniques were adopted for the VVC standard. After each meeting, the VVC working draft and test model VTM are updated. The project is currently aiming for technical completion (FDIS) at the July 2020 meeting. There are.

[0042] 3.1. Picture Partitioning Scheme in HEVC HEVC has regular slices, dependent slices, tiles, WPP (Waveform Presets) Four different image segmentation techniques are used: By applying these, maximum transmission unit (MTU) size matching can be achieved. ,Parallel processing, reduces end-to-end delay.

[0043] Regular slices are similar to H.264 / AVC. Each regular slice is its own NAL units and performs in-picture prediction across slice boundaries (intra- sample prediction, motion prediction, coding mode prediction) and entropy coding In this way, one regular slice can be overridden by other slices in the same picture. It can be reconstructed independently of the regular slices (but the loop filtering operation (There may still be interdependencies due to the nature of the work).

[0044] Regular slicing is the only tool available for parallelization, even in H.264 / AVC. It can be used in almost the same way. Regular slice-based parallelism is achieved by inter-processor communication or Requires less inter-core communication (movement when decoding predictively coded pictures) Except for inter-processor or inter-core data sharing for compensation, intra-picture prediction is typically Therefore, it is much heavier than inter-processor or inter-core data sharing. For this reason, regular slices require a bit cost for the slice header and slice boundary. The lack of field-wide predictions results in significant coding overhead. Furthermore, regular slicing (as opposed to other tools discussed below) Intra-picture independence of regular slices and each regular slice has its own NAL bits to accommodate MTU size requirements due to being encapsulated in units It also serves as a key mechanism for splitting streams, often parallelizing them. The goal of matching the MTU size is inconsistent with the slice layout in the image. This situation has led to the development of the following parallelization tools: was issued.

[0045] Dependent slices have short slice headers and do not suspend intra-picture prediction at all. This allows for partitioning of the bitstream at treeblock boundaries rather than at the A dependent slice is a regular slice fragmented into multiple NAL units, and the entire regular slice is By allowing some of the regular slices to be sent before the field encoding is complete, to reduce end-to-end delay.

[0046] In WPP, a picture is divided into single-row coding tree blocks (CTBs). Entropy decoding and prediction uses data from the CTB in other partitions. Parallel processing is possible by parallel decoding of CTB rows, and one CTB The start of row decoding is delayed by two CTBs, allowing the target CTB to be decoded. Before this, data on the CTB to the right of the target CTB is available. By using a wave front (which looks like a wave front when represented graphically), It is possible to parallelize the processor with up to the number of processors / cores that the processor contains in the CTB row. Since intra-picture prediction between neighboring treeblock rows in a picture is allowed, The inter-processing unit / inter-core communication required to enable intra-prediction may be sufficient. does not result in the generation of additional NAL units compared to the case where it is not applied, and therefore WPP is not a tool for MTU size matching, but it is a tool for MTU size matching. If switching is required, regular switching can be achieved in WPP with some coding overhead. Rice can be used.

[0047] Tiles define horizontal and vertical boundaries that divide the picture into columns and rows of tiles. Columns of tiles run from top to bottom across the picture. Similarly, rows of tiles run from left to right across the picture. The number of tiles in a picture is simply the number of tile columns multiplied by the number of tile rows. This can be obtained by:

[0048] The scan order of the CTB is local within one tile (the CTB of one tile TB raster scan order) and then tile raster scan of one picture The CTB in the top left corner of the next tile is decoded in the order shown. However, this compromises the intra-picture prediction dependency and the entropy decoding dependency. These do not need to be contained in individual NAL units (which is the same as WPP in this respect), and therefore Tiles cannot be used for MTU size matching. Each tile is used by one processor / computer. The processor / computer required for intra-picture prediction between the processing units may be In inter-slicer communication, decoding of neighboring tiles is performed when one slice spans two or more tiles. If so, propagation of shared slice headers and looping of reconstructed samples and metadata Limited to sharing related to filtering. If a WPP segment is included, each tile in the slice other than the first one or The entry point byte offset of the WPP segment is not specified in the slice header. The number will be notified.

[0049] For simplicity, HEVC uses four different picture splitting methods: A given coded video sequence is For most of the profiles specified in the For each slice and tile, one or both of the following conditions must be met: 1) All coding tree blocks in one slice must be belong to the same tile, and 2) all coding tree blocks in one tile are belong to the same slice. Finally, one wavefront segment contains exactly one CTB row. When WPP is used, if one slice starts within one CTB row, It must end with a CTB line.

[0050] Recent HEVC amendments include the JCT-VC output document JCTVC-AC1005, J. Boyce, A. Ramasubramonian, R. Sukupin, G.J. Suri, A. Tulapis , Y.-K. Wang (editors), “HEVC Additional Capture Enhancement Information” (Draft 4), “Oct.24,2017, Available at: http: / / phenix.in t-evry.fr / jct / doc_end_user / documents / 29_ Macau / wg11 / JCTVC-AC1005-v2.zip including this correction, HE The VC sends three MCTS-related SEI messages: the time MCTS SEI (Supplementary Enhancement Information) message, MCTS Extracted Information Set SEI message, and MCTS Extracted Information Identify the nested SEI message.

[0051] The time MCTS SEI message indicates the presence of an MCTS in the bitstream. In each MCTS, the motion vector is and only require full sample positions inside the MCTS for interpolation. Fractional sample locations are restricted to point to blocks outside the MCTS. The use of motion vector candidates derived from this for temporal motion vector prediction is not permitted. As shown in Fig. 1, each MCTS is decoded independently, with no tiles not included in the MCTS. This may also be done.

[0052] The MCTS Extraction Information Set (SEI) message is used to extract the MCTS sub-bitstream (S Provides supplementary information that may be used in the EI message (defined as part of the message meaning) , generate a conforming bitstream for the MCTS set. This information is extracted from the extracted information set. Each extracted information set defines the number of MCTS sets, and the MCTS sub-bits RBSP balances for alternate VPS, SPS, and PPS used in stream extraction processing The MCTS sub-bitstream extraction process extracts the sub-bitstreams. When extracting, rewrite or replace the parameter set (VPS, SPS, PPS). The reason is that one of the syntax elements related to the slice address or All (first_slice_segment_in_pic_flag and sli ce_segment_address) must be different values. .

[0053] 3.2. Picture Segmentation in VVC In VVC, a picture consists of one or more tile rows and one or more tile columns. A tile is a sequence of CTUs that covers a rectangular area of ​​an image. The CTUs in a tile are scanned in raster scan order within that tile. will be downloaded.

[0054] A slice is an integer number of complete tiles or Contains an integer number of consecutive complete CTU rows.

[0055] Two modes of slicing: raster scan slicing mode and rectangular slicing mode. In raster scan slice mode, one slice corresponds to one Contains one complete sequence of tiles in the tile raster scan of a picture. In slice mode, a slice is a complete block that collectively forms a rectangular area of ​​the picture. The total number of tiles, or the number of consecutive tiles in a single tile that collectively form a rectangular area of ​​the picture. The number of complete CTU rows containing any one tile within a rectangular slice corresponds to that slice. The tiles are scanned in the rectangular area in the order of the raster scan.

[0056] A subpicture is one or more slices that collectively cover a rectangular area of ​​a picture. Includes:

[0057] FIG. 1 shows an example of raster scan slice partitioning of a picture, where the picture is divided into 12 time segments. The image is divided into a file and three raster scan slices.

[0058] FIG. 2 shows an example of rectangular slice partitioning of a picture, where the picture is divided into 24 tiles (6 The image is divided into 4 tile columns and 4 tile rows) and 9 rectangular slices.

[0059] Figure 3 shows an example of a picture divided into tiles and rectangular slices. is divided into four tiles (two tile columns and two tile rows) and four rectangular slices. It will be divided.

[0060] FIG. 4 shows an example of dividing one picture into sub-pictures. One picture is divided into 18 sub-pictures. The leftmost 12 tiles each contain one slice of the 4x4 CTU. The six tiles on the right represent vertically stacked slices of a 2x2 CTU. This results in a total of 24 slices and 24 sub-pictures of different sizes (each slice Rice is one subpicture).

[0061] 3.3 SPS / PPS / Picture header / Slice in VVC Header signaling 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0062] [Table 1] [Table 2] [Table 3] [Table 4] [Table 5] [Table 6]

[0063] 7.3.2.4 Picture parameter set RBSP syntax

[0064] [Table 7] [Table 8] [Table 9] [Table 10]

[0065] 7.3.2.7 Picture Header Structure Syntax

[0066] [Table 11] [Table 12] [Table 13] [Table 14]

[0067] 7.3.7.1 General Slice Segment Header Syntax [Table 15] [Table 16] [Table 17]

[0068] 3.4 Tile, Slice, and Subpicture Specification Examples 3 Definition Picture-level slice index: rect_slice_flag equals 1 If so, slices are assigned to the list of slices in the picture in the order signaled in the PPS. Indicates the chair index. Subpicture level slice index: rect_slice_flag equals 1 If necessary, the slices are sorted into a list of slices in the subpicture in the order signaled in the PPS. Rice index is shown. 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing The variable NumTileColumns that specifies the number of tile columns, and the i-th column in CTB units. The range for i is from 0 to NumTileColumn-1 (both The list colWidth[i] (including the edges) is derived as follows: remainingWidthInCtbsY=PicWidthInCtbsY for(i=0;i <num_exp_tile_columns_minus1; i++){ colWidth[i]=tile_column_width_minus1[i ]+1 remainingWidthInCtbsY-=colWidth[i] } uniformTileColWidth=tile_column_width_m inus1[num_exp_tile_columns_minus1]+1 (2 3) while(remainingWidthInCtbsY>=uniformTil eColWidth){ colWidth[i++]=uniformTileColWidth remainingWidthInCtbsY-=uniformTileColW idth } if(remainingWidthInCtbsY>0) colWidth[i++]=remainingWidthInCtbsY NumTileColumns=i The variable NumTileRows specifies the number of tile rows, and the jth tile row in CTB units. j in the range 0 to NumTileRows-1 (inclusive) that specifies the height of the tile row. The list RowHeight[j] is derived as follows: remainingHeightInCtbsY=PicHeightInCtbsY for(j=0;j <num_exp_tile_rows_minus1;j++) { RowHeight[j]=tile_row_height_minus1[j] +1 remainingHeightInCtbsY-=RowHeight[j] } uniformTileRowHeight=tile_row_height_mi nus1[num_exp_tile_rows_minus1]+1 (24) while(remainingHeightInCtbsY>=uniformTi leRowHeight){ RowHeight[j++]=uniformTileRowHeight remainingHeightInCtbsY-=uniformTileRow Height } if(remainingHeightInCtbsY>0) RowHeight[j++]=remainingHeightInCtbsY NumTileRows=j The variable NumTileInPic is NumTileColumns*NumTileR ows. If i is in the range 0 to NumTileColumns (inclusive), and the CTB To specify the position of the ith tile column boundary in a row, the list tileColBd[i] is It is derived as follows: for(tileColBd[0]=0,i=0;i <NumTileColumns ;i++) tileColBd[i+1]=tileColBd[i]+colWidth[i ] (twenty five) Note 1 - The size of the array tileColBd[] is One more than the actual number of tile columns. Specifies the jth tile row boundary position in CTB units, where j is from 0 to NumTileRow The list tileRowBd[j] in the range up to s (inclusive) is derived as follows: will be done. for(tileRowBd[0]=0,j=0;j <NumTileRows;j+ +) tileRowBd[j+1]=tileRowBd[j]+RowHeight[ j] (26) Note 2 - The size of the array tileRowBd[] in the above derivation is One more than the actual number of tile rows in the derivation of wBd[ ]. Specifies the translation from horizontal CTB address to left tile column boundary in CTB units, 0 to P List of ctbAddrX in the range up to icWidthInCtbsY (inclusive) bToTileColBd[ctbAddrX] is derived as follows: tileX=0 for(ctbAddrX=0;ctbAddrX<=PicWidthInCtbs Y;ctbAddrX++){ if(ctbAddrX==tileColBd[tileX+1])(27) tileX++ CtbToTileColBd[ctbAddrX]=tileColBd[tile X] } Note 3 - The size of the array CtbToTileColBd[] in the above derivation is slice_data() signaling the actual picture in the CTB The number of bytes is one greater than the number of bytes. ctbAddrY is in the range from 0 to PicHeightInCtbsY (inclusive) to specify the translation from vertical CTB addresses to the top tile column boundary in CTB units. The list CtbToTileRowBd[ctbAddrY] is derived as follows: do. tileY=0 for(ctbAddrY=0;ctbAddrY<=PicHeightInCtb sY;ctbAddrY++){ if(ctbAddrY==tileRowBd[tileY+1])(28) tileY++ CtbToTileRowBd[ctbAddrY]=tileRowBd[til eY] } Note 4 - The size of the array CtbToleRowBd[] in the above derivation is slice_ One more than the actual picture height in the CTB in the data() signaling . For rectangular slices, i goes from 0 to num_slices_in_pic_minus1 NumCtusInSlice[i] is the list of the range (inclusive) of Specifies the number of CTUs in, where i ranges from 0 to num_slices_in_pic_min The list SliceTopLeftTileIdx[i] of the range of us1 (inclusive) is Specifies the index of the top-left tile of the slice, j ranges from 0 to NumCtusInSli The jth CTB picture in the i-th slice in the range ce[i]-1 (inclusive) Specifies the raster scan address and is derived as follows: if(single_slice_per_subpic_flag){ for(i=0;i<=sps_num_subpics_minus1;i++) NumCtusInSlice[i]=0 for(i=0;i<PicSizeInCtbsY;i++){ sliceIdx=subpic_info_present_flag?Ctb ToSubpicIdx[i]:0 CtbAddrInSlice[sliceIdx][NumCtusInSli ce[sliceIdx]]=i NumCtusInSlice[sliceIdx]++ } }else{ tileIdx=0 for(i=0;i<=num_slices_in_pic_minus1;i+ +) NumCtusInSlice[i]=0 for(i=0;i<=num_slices_in_pic_minus1;i+ +){ SliceTopLeftTileIdx[i]=tileIdx tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns if(i==num_slices_in_pic_minus1){ slice_width_in_tiles_minus1[i]=NumTi leColumns-1-tileX slice_height_in_tiles_minus1[i]=NumT ileRows-1-tileY NumSlicesInTile[i]=1 } if(slice_width_in_tiles_minus1[i]==0& &slice_height_in_tiles_minus1[i]==0){(29 ) ctbY=tileRowBd[tileY] for(j=0;j<NumSlicesInTile[i]-1;j++){ AddCtbsToSlice(i,tileColBd[tileX],t ileColBd[tileX+1],ctbY,ctbY+SliceHeightI nCtusMinus1[i]+1) ctbY+=SliceHeightInCtusMinus1[i]+1 i++ } AddCtbsToSlice(i,tileColBd[tileX],ti leColBd[tileX+1],ctbY,tileRowBd[tileY+1] ) }else for(j=0;j<=slice_height_in_tiles_min us1[i];j++) for(k=0;k<=slice_width_in_tiles_min us1[i];k++) AddCtbsToSlice(i,tileColBd[tileX+k] ,tileColBd[tileX+k+1],tileRowBd[tileY+j] ,tileRowBd[tileY+j+1]) if(tile_idx_delta_present_flag) tileIdx+=tile_idx_delta[i] else{ tileIdx+=slice_width_in_tiles_minus1 [i]+1 if(tileIdx%NumTileColumns==0) tileIdx+=slice_height_in_tiles_minu s1[i]*NumTileColumns }} } Function AddCtbsToSlice(sliceIdx,startX,stopX, startY, stopY) are defined as follows: for(ctbY=startY;ctbY <stopY;ctbY++) for(ctbX=startX;ctbX <stopX;ctbX++){ CtbAddrInSlice[sliceIdx][NumCtusInSli ce[sliceIdx]]=ctbY*PicWidthInCtbsY+ctbX (30) NumCtusInSlice[sliceIdx]++ } i is in the range 0 to num_slices_in_pic_minus1 (inclusive) ), the value of NumCtusInSlice[i] must be greater than 0. This is a requirement for bitstream compliance. c_minus1 inclusive, j ranges from 0 to NumCtusInSlice The matrix CtbAddrInSlice[i][j], which is in the range [i]-1 (inclusive), is , all CTB addresses in the range 0 to PicSizeInCtbsY-1 (inclusive) It is a bitstream compliance requirement that the .htaccess file should contain the .htaccess file only once. Conversion from CTB address to subpicture index in picture raster scan A ct in the range 0 to PicSizeInCtbsY_1 (inclusive) that specifies the conversion The list of bAddrRs, CtbToSubpicIdx[ctbAddrRs], is It is derived as follows. for(ctbAddrRs=0;ctbAddrRs <PicSizeInCtbs Y;ctbAddrRs++){ posX=ctbAddrRs%PicWidthInCtbsY posY=ctbAddrRs / PicWidthInCtbsY CtbToSubpicIdx[ctbAddrRs]=-1 for(i=0;CtbToSubpicIdx[ctbAddrRs]<0&&i <=sps_num_subpics_minus1;i++){ (31) if((posX>=subpic_ctu_top_left_x[i])&& (posX <subpic_ctu_top_left_x[i]+subpi c_width_minus1[i]+1)&& (posY>=subpic_ctu_top_left_y[i])&& (posY <subpic_ctu_top_left_y[i]+subpi c_height_minus1[i]+1)) CtbToSubpicIdx[ctbAddrRs]=i } } A list NumSlicesInS specifying the number of rectangular slices in the ith subpicture ubpic[i] is derived as follows: for(j=0;j<=sps_num_subpics_minus1;j++) NumSlicesInSubpic[j]=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ){ posX=CtbAddrInSlice[i][0]%PicWidthInCt bsY posY=CtbAddrInSlice[i][0] / PicWidthInCt bsY for(j=0;j<=sps_num_subpics_minus1;j++) { if((posX>=subpic_ctu_top_left_x[j])&& (32) (posX <subpic_ctu_top_left_x[j]+subpi c_width_minus1[j]+1)&& (posY>=subpic_ctu_top_left_y[j])&& (posY <subpic_ctu_top_left_y[j]+subpi c_height_minus1[j]+1)){ NumSlicesInSubpic[j]++ } } }

[0069] 7.3.4.3 Picture parameter set RBSP semantics If subpic_id_mapping_in_pps_flag is equal to 1, This specifies that picture ID mapping is signaled in the PPS. If subpic_id_mapping_in_pps_flag is equal to 0, P Specifies that the mapping of subpicture IDs is not signaled in PS. pic_id_mapping_explicitly_signalled_flag is equal to 0 or subpic_id_mapping_in_sps_fla If g is equal to 1, then subpic_id_mapping_in_pps_flag The value of (subpic_id_mapping_ex) shall be equal to 0. plicitly_signalled_flag is equal to 1 and subpic_ id_mapping_in_sps_flag is equal to 0), subpic_i The value of d_mapping_in_pps_flag shall be equal to 1. pps_num_subpics_minus1 is sps_num_subpics Let it be equal to _minus1. pps_subpic_id_len_minus1 is sps_subpic_id Let it be equal to _len_minus1. pps_subpic_id[i] specifies the subpicture ID of the ith subpicture. The length of the pps_subpic_id[i] syntax element is id_len_minus1+1 bits. The variable SubpicIdVal[i] ranges from 0 to sps_num_subpics_mi For each value of i in the range of nus1 (inclusive), it is derived as follows: for(i=0;i<=sps_num_subpics_minus1;i++) if(subpic_id_mapping_explicitly_signal led_flag) SubpicIdVal[i]=subpic_id_mapping_in_p ps_flag?pps_subpic_id[i]:sps_subpic_id[i ] (80) else SubpicIdVal[i]=i A requirement for bitstream conformance is that both of the following constraints apply: - i and in the range 0 to sps_num_subpics_minus1 (inclusive) For any two distinct values ​​of j and j, SubpicIdVal[i] is the same as SubpicId It shall not be equal to Val[j]. - 0 to sps_num_s if the current picture is not the first picture in CLVS For each value of i in the range ubpics_minus1 (inclusive), SubpicId The value of Val[i] is the same as the SubpicIdVa value of the previous picture in decoding order in the same layer. If l[i] is not equal to the value of the current picture with subpicture index i, nal_u of all coded slice NAL units of the subpicture in nit_type is a characteristic in the range from IDR_W_RADL to CRA_NUT (inclusive). shall be equal to the specified value. If no_pic_partition_flag is equal to 1, each PPS reference Specifies that picture partitioning is not applied to the picture. If no_pic_partition_flag is equal to 0, each PPS that references It specifies that a picture may be divided into multiple tiles or slices. For all PPSs referenced by coded pictures within one CLV The value of no_pic_partition_flag must be the same for Stream conformance requirements. If the value of sps_num_subpics_minus1+1 is greater than 1, no The value of _pic_partition_flag not equal to 1 indicates that the bitstream This is a system compliance requirement. pps_log2_ctu_size_minus5 plus 5 is the luminance code of each CTU Specifies the coding tree block size. pps_log2_ctu_size_minus5 is sps_log2_ctu_ shall be equal to size_minus5. num_exp_tile_columns_minus1 plus 1 is clearly provided num_exp_tile_columns_mi Specifies the number of tile columns widths to be used. The value of nus1 should be in the range 0 to PicWidthInCtbsY-1. If no_pic_partition_flag is equal to 1, then num_exp The value of _tile_columns_minus1 is inferred to be equal to 0. num_exp_tile_rows_minus1 plus 1 is the number of tiles provided explicitly. Specifies the number of tile rows in height. The value should be in the range 0 to PicHeightInCtbsY-1. If o_pic_partition_flag is equal to 1, then num_tile_ro The value of ws_minus1 is inferred to be equal to 0. tile_column_width_minus1[i] plus 1 for the i-th tile Specifies the width of the tile columns in the range 0 to num_exp_tile_columns_minus1-1. Specifies the width of the ith tile column in the range in CTB units. idth_minus1[num_exp_tile_columns_minus1] is the number of tile columns in a table, as specified in Section 6.5.1. nus is an index greater than or equal to 1 that is used to derive the width of the tile column. The value of column_width_minus1[i] ranges from 0 to PicWidthInC Should be in the range of tbsY-1. If not present, tile_column The value of _width_minus1[0] is equal to PicWidthInCtbsY-1. It is estimated that tile_row_height_minus1[i] plus 1 for the ith tile row Set the height of the tile to the range 0 to num_exp_tile_rows_minus1-1 (both ends) tile_row_h Specifies the height of the ith tile row in the grid (including the grid) in CTB units. eight_minus1[num_exp_tile_rows_minus1] is num_exp_tile_rows_minus1 or greater as specified in Section 6.5.1 Used to derive the height of the tile row at the index above. The value of height_minus1[i] ranges from 0 to PicHeightInCtbsY- Should be in the range 1 to 1. If not present, tile_row_height_ The value of minus1[0] is inferred to be equal to PicHeightInCtbsY_1. do. If rect_slice_flag is equal to 0, the tiles in each slice are rasterized. It specifies that the slices are arranged in scan order and that slice information is not signaled in the PPS. If rect_slice_flag is equal to 1, the tiles in each slice are It specifies that the slice information is signaled in the PPS. If not, rect_slice_flag is inferred to be equal to 1. If _info_present_flag is equal to 1, then rect_slice_fl The value of ag is 1. If single_slice_per_subpic_flag is equal to 1, each subpic A picture consists of only one rectangular slice. If _subpic_flag is equal to 0, each subpicture consists of one or more rectangular slides. It specifies that the slice may consist of a single slice. If ic_flag is equal to 1, then num_slices_in_pic_minus1 is inferred to be equal to sps_num_subpics_minus1. If not present, In this case, the value of single_slice_per_subpic_flag is assumed to be equal to 0. It is measured. num_slices_in_pic_minus1 plus 1 refers to each PPS num_slices_in_pic_min Specifies the number of rectangular slices in a picture. The value of us1 ranges from 0 to MaxSlicesPerPicture-1 (inclusive). and MaxSlicesPerPicture shall be as specified in Annex A. If o_pic_partition_flag is 1, then num_slices_in_ The value of pic_minus1 is inferred to be equal to 0. If tile_idx_delta_present_flag is equal to 0, PPS tile_idx_delta value is not present in the All rectangular slices in the picture that references the PPS are processed in raster order according to the process described above. If tile_idx_delta_present_flag is equal to 1, , specifies that the tile_idx_delta value may be present in the PPS, and refers to the PPS. All rectangular slices of the picture referenced are sorted by the value of tile_idx_delta. If not present, tile_idx_delta_pres The value of nt_flag is inferred to be 0. slice_width_in_tiles_minus1[i] plus 1 is the ith slice_width_in_t Specifies the width of a rectangular slice of the The value of iles_minus1[i] ranges from 0 to NumTileColumns-1. It should be within the range. slice_width_in_tiles_minus1[ If i] is not present, then the following applies: - If NumTileColumns is equal to 1, slice_width_in_ The value of tiles_minus1[i] is inferred to be equal to 0. - otherwise, slice_width_in as specified in Section 6.5.1 Infer the value of _tiles_minus1[i]. slice_height_in_tiles_minus1[i] plus 1 is the i-th Specifies the height of the rectangular slice of the eye in tile rows. The value of tiles_minus1[i] ranges from 0 to NumTileRows-1. slice_height_in_tiles_minus1[i ] is not present, the following applies: - If NumTileRows is equal to 1 or tile_idx_delta_ present_flag is equal to 0 and tileIdx%NumTileColu slice_height_in_tiles_minus if mns is greater than 0 The value of 1[i] is inferred to be equal to 0. - Otherwise (NumTileRows is not equal to 1 and tile_id x_delta_present_flag is equal to 1 or tileIdx%Num TileColumns equals 0), tile_idx_delta_pres ent_flag is equal to 1 or tileIdx%NumTileColumns If is equal to 0, slice_height_in_tiles_minus1[i] The value of is equal to slice_height_in_tiles_minus1[i-1]. It is inferred that num_exp_slices_in_tile[i] specifies two or more rectangular slices Specifies the number of slice heights provided explicitly for the current tile, including The value of _slices_in_tile[i] ranges from 0 to RowHeight[tileY ]-1 (inclusive), where tileY is the tile containing the i-th slice. If not present, num_exp_slices_in_ti The value of le[i] is inferred to be equal to 0. If le[i] is equal to 0, the value of the variable NumSlicesInTile[i] is equal to 1. It is derived as follows. exp_slice_height_in_ctus_minus1[j] plus 1 is , specifies the height of the jth rectangular slice in the current tile in CTU rows. The value of _slice_height_in_ctus_minus1[j] ranges from 0 to Ro The range is wHeight[tileY]-1 (inclusive), where tileY is The tile row index of the current tile. If num_exp_slices_in_tile[i] is greater than the variable, then 0 to Variable NumSlices for k in the range NumSlicesInTile[i]-1 InTile[i] and SliceHeightInCtusMinus1[i+k] are It is derived as follows: remainingHeightInCtbsY=RowHeight[SliceT opLeftTileIdx[i] / NumTileColumns] numExpSliceInTile=num_exp_slices_in_til e[i] for(j=0;j <numExpSliceInTile-1;j++){ SliceHeightInCtusMinus1[i++]=exp_slice _height_in_ctu_minus1[j] remainingHeightInCtbsY-=SliceHeightInC tusMinus1[j] } uniformSliceHeightMinus1=SliceHeightInC tusMinus1[i-1] (81) while(remainingHeightInCtbsY>=(uniformS liceHeightMinus1+1)){ SliceHeightInCtusMinus1[i++]=uniformSl iceHeightMinus1 remainingHeightInCtbsY-=(uniformSliceH eightMinus1+1) j++ } if(remainingHeightInCtbsY>0){ SliceHeightInCtusMinus1[i++]=remaining HeightInCtbsY j++ } NumSlicesInTile[i]=j tile_idx_delta[i] is the tile of the first tile in the i-th rectangular slice. the tile index of the first tile in the (i+1)th rectangular slice, and the tile index of the first tile in the (i+1)th rectangular slice. The value of tile_idx_delta[i] specifies the difference between -NumTilesIn It should be in the range of Pic+1 to NumTilesInPic-1. If not present, the value of tile_idx_delta[i]i is inferred to be equal to 0. If tile_idx_delta[i] is specified, the value of tile_idx_delta[i] is inferred to be equal to 0. …

[0070] 7.4.2.4.5 VCL NAL unit order and its coded pictures Association to Cha The order of VCL NAL units in a coded picture is as follows: It is restricted. - Any two coded slices of one coded picture NA For L units A and B, let subpicIdxA and subpicIdxB be their Let sliceAddrA and sliceddr be the subpicture level index values ​​of Let B be their slice_address value. - a coded slice NAL unit if any of the following conditions are true: Let A precede coded slice NAL unit B. - subpicIdxA is less than subpicIdxB. - subpicIdxA is equal to subpicIdxB, and sliceAddrA is equal to sliceAddrB is less than sliceAddrB.

[0071] 7.4.8.1 General slice header semantics Luma quantization parameter for coding units, including Cu_qp_delta_abs The variable CuQpDeltaVal, which defines the difference between the QpQp and its predicted value, is set equal to zero. Coding unit quantizer, including cu_chroma_qp_offset_flag The parameter Qp' Cb ,Qp' Cr ,Qp' CbCr Used to determine each value of CuQpOffset variable that specifies the value Cb ,CuQpOffset Cr is all It is set equal to 0. picture_header_in_slice_header_flag equals 1 If necessary, the slice header contains a PH syntax structure. If in_slice_header_flag is equal to 0, the slice header contains the PH structure. There is no sentence structure. picture_head for all coded slices in CLVS The same value of er_in_slice_header_flag indicates that the bitstream This is a stream conformance requirement. coded slice picture_header_in_slice_h If leader_flag is equal to 1, then nal_unit_type is P in CLVS. Conformance requires that there be no VCL NAL units that are H_NUT. picture_header_in_slice_header_flag is equal to 0 If so, all coded slices of the current picture are stored in picture_h The header_in_slice_header_flag is equal to 0 and the current PU shall have PH NAL units. slice_subpic_id is the subpicture ID of the subpicture that contains the slice If slice_subpic_id exists, the variable CurrSubpi The value of cIdx is the slice of SubpicIdVal[CurrSubpicIdx]. _subpic_id is derived to be equal to (slice_s If the subpic_id does not exist, CurrSubpicIdx will be equal to 0. The length of slice_subpic_id is d_len_minus1+1 bits. slice_address specifies the slice address of the slice. In this case, the value of slice_address is inferred to be equal to 0. e_flag is 1 and NumSlicesInSubpic[CurrSubpicIdx If ] is equal to 1, the value of slice_address is inferred to be 0. If rect_slice_flag is equal to 0, the following applies: - The slice address is the raster scan tile index. - The length of slice_address is Ceil(Log2(NumTilesIn Pic)) bit. - slice_address is a value between 0 and NumTilesInPic-1 It should be within range. Otherwise (rect_slice_flag is equal to 1), the following applies: can be. - The slice address is the sub-picture level slice index of the slice. - The length of slice_address is Ceil(Log2(NumSlicesI nSubpic[CurrSubpicIdx])) bits. - The value of slice_address ranges from 0 to NumSlicesInSubpic[ CurrSubpicIdx]-1. The requirements for bitstream conformance are that the following constraints apply: - rect_slice_flag is equal to 0 or subpic_info_pr If esent_flag is equal to 0, the value of slice_address must be the same as Any other coded slice NAL unit in the coded picture slice_address must not be equal to the value of slice_address. - Otherwise, slice_subpic_id and slice_address The set of values ​​is the same as any other coded sequence in the same coded picture. slice_subpic_id and slice_address of the slice NAL unit The value pair must not be equal. - The shape of a slice of a picture is such that each CTU, when decoded, has its entire left boundary and its most The entire upper boundary is the boundary of one picture or contains the boundary of a previously decoded CTU. It must be. sh_extra_bit[i] may be equal to 1 or 0. Conforming decoders should ignore the value of sh_extra_bit[i]. does not affect the conformance of the decoder to the features specified in this version of the specification. stomach. num_tiles_in_slice_minus1 plus 1, if present, Specifies the number of tiles in a slice. num_tiles_in_slice_minus1 The value should be in the range 0 to NumTilesInPic-1. The variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice and for i in the range 0 to NumCtusInCurrSlice-1 (inclusive) , a list Ct specifying the picture raster scan address of the ith CTB in the slice bAddrInCurrSlice[i] is derived as follows: if(rect_slice_flag){ picLevelSliceIdx=slice_address for(j=0;j <CurrSubpicIdx;j++) picLevelSliceIdx+=NumSlicesInSubpic[j ] NumCtusInCurrSlice=NumCtusInSlice[picL evelSliceIdx] for(i=0;i <NumCtusInCurrSlice;i++) CtbAddrInCurrSlice[i]=CtbAddrInSlice[ picLevelSliceIdx][i] (117) }else{ NumCtusInCurrSlice=0 for(tileIdx=slice_address;tileIdx<=sli ce_address+num_tiles_in_slice_minus1;til eIdx++){ tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns for(ctbY=tileRowBd[tileY];ctbY <tileRo wBd[tileY+1];ctbY++){ for(ctbX=tileColBd[tileX];ctbX <tileC olBd[tileX+1];ctbX++){ CtbAddrInCurrSlice[NumCtusInCurrSli ce]=ctbY*PicWidthInCtb+ctbX NumCtusInCurrSlice++ } } } } The variables SubpicLeftBoundaryPos, SubpicTopBounda ryPos, SubpicRightBoundaryPos, SubpicBotBo undaryPos are derived as follows. if(subpic_treated_as_pic_flag[CurrSubpi cIdx]){ SubpicLeftBoundaryPos=subpic_ctu_top_l eft_x[CurrSubpicIdx]*CtbSizeY SubpicRightBoundaryPos=Min(pic_width_m ax_in_luma_samples-1, (subpic_ctu_top_left_x[CurrSubpicIdx] + subpic_width_minus1[CurrSubpicIdx]+1) *CtbSizeY-1) SubpicTopBoundaryPos=subpic_ctu_top_le ft_y[CurrSubpicIdx]*CtbSizeY (118) SubpicBotBoundaryPos=Min(pic_height_ma x_in_luma_samples-1, (subpic_ctu_top_left_y[CurrSubpicIdx] + subpic_height_minus1[CurrSubpicIdx]+1 )*CtbSizeY-1) }

[0072] 3.5 Color Spaces and Chroma Subsampling A color space, also known as a color model (or color system), is a set of numerical tags that represent a range of colors. It is an abstract mathematical model that is easily described as a tuple, typically consisting of 3 or Four values ​​or color components (e.g. RGB). Basically, a color space is a coordinate system and a subspace. This is a refinement of the above.

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

[0074] YCbCr, Y'CbCr, or Y Pb / Cb Pr / Cr are YCBCR or Also known as Y'CBCR, it is a part of the color imaging pipeline of video and digital photography systems. It is a family of color spaces that are used as part of the RGB color space. Y' is the luminance component, and CB and CR are the blue-difference and red-difference chroma components. Y' (which has a prime number) is distinct from Y, which is the luminance component. that the light intensity is coded nonlinearly based on gamma-corrected RGB primaries. means.

[0075] Chroma subsampling is because the human visual system has a lower perception of color difference than luminance. Taking advantage of this, the chrominance information is implemented with a lower resolution than the luminance information, resulting in a picture This is a method for encoding cha.

[0076] 3.5.1. 4:4:4 Each of the three Y'CbCr components has the same sample rate and therefore the chroma sub-sampler This method is not compatible with high-end film scanners and cinematic It is sometimes used in post-production.

[0077] 3.5.2. 4:2:2 The two chrominance components are sampled at half the luma sample rate, resulting in a horizontal chrominance resolution of The image resolution is halved and the vertical chroma resolution remains unchanged. This results in a visually almost 4:2: There is no difference between the two and it can reduce the bandwidth of the uncompressed video signal by a factor of three. Examples of nominal vertical and horizontal positions for two-color formats are given, for example, in the VVC working draft This is shown in Figure 5.

[0078] 3.5.3. 4:2:0 In 4:2:0, the horizontal sampling is doubled compared to 4:1:1, but this scheme Since the Cb and Cr channels are sampled only on every other line, the vertical resolution is The horizontal and vertical axes are halved, so the data rate remains the same. Cb and Cr are horizontal and vertical axes, respectively. Subsampled by a factor of 2 in both the vertical and horizontal directions. There are three variants of the :2:0 scheme: ● In MPEG-2, Cb and Cr are horizontally co-located. Cb and Cr is located between pixels in the vertical direction (located between the grids). ● In JPEG / JFIF, H.261, and MPEG-1, Cb, and Cr is located between the grids in between the alternating luminance samples. ● 4:2: In the variable DV, Cb and Cr are co-located in the horizontal direction. In the above, they co-occur alternately. Table 3-1. chroma_format_idc and separate_colour SubWidthC and SubHeightC derived from r_plane_flag Value of

[0079] [Table 18]

[0080] 4. Examples of Technical Problems to be Solved by the Disclosed Embodiments Existing VVC signaling schemes for SPS / PPS / picture headers / slice headers The existing design has the following problems: 1) If rect_slice_flag is equal to 1, the text of the current VVC If so, it will look like this: a.slice_address is the subpicture-level slice index of the slice. Represents sex. b. Subpicture level slice index refers to the slice of a subpicture. It is defined as the slice's index into the ordered list signaled by PS. c. Picture-level slice index is the slice index within a picture in PPS. It is defined as the index of the slice into the signaled ordered list. d. For two slices that belong to two different subpictures, The smaller the index, the earlier the decoding order, and the more likely two slices belong to the same subpicture. In this regard, the smaller the slice index at the sub-picture level, the earlier the decoding order. e. And the variable NumCtusInCurr that specifies the number of CTUs in the current slice The derivation of Slice in this VVC text, equation 117, is a picture-level slice. It is assumed that the increasing order of the index values ​​is the same as the decoding order of the slices. However, if a tile is divided into several slices, as shown above, In the example shown in Figure 6, the picture is split by a vertical tile boundary. The image is divided into two tiles, each of which has the same water content across the entire picture. If the image is divided into two slices by a horizontal boundary, the top two slices are the first slice. The first slice is included in the first subpicture, and the bottom two slices are included in the second subpicture. According to current VVC text, a picture of four slices in slice raster scan order The slice index values ​​for the levels are 0, 2, 1, and 3, in slice raster scan order. The decoding order index values ​​for the four slices are 0, 1, 2, and 3. , the derivation of NumCtusInCurrSlice is now incorrect, and the solution for slice data This can cause problems with the analysis, resulting in incorrect decoded sample values ​​and a decoder crash. The possibility becomes higher. 2) There are two types of slice signaling. In rectangular mode, all slice division information is In non-rectangular mode, some slice division information is communicated in the slice header. This mode ensures that the complete picture is read before analyzing all slices of the picture. The exact slice division cannot be known. 3) In rectangular mode, you can set the tile_idx_delta to make the slices arbitrary. A malicious bitstream can trick a decoder into May cause crashes. 4) In an embodiment of the present invention, i is num_slices_in_pic_minus1 If equal to , uninitialized tile_idx_delta[i]

[0081] Figure 6 shows an example of picture division. Solid lines 602 indicate tile boundaries, and dashed lines 604 indicate tile boundaries. The dashed lines 606 represent the boundaries of the sub-pictures. picture level index, decoding order index, sub-picture level index, and The subpicture and tile indices are shown.

[0082] 5. Exemplary Embodiments and Techniques In order to solve the above-mentioned problems, the following method is disclosed. These should be seen as illustrative examples of general concepts and should not be interpreted in a narrow sense. Furthermore, the present invention may be applied individually or in any combination. stomach. 1. Slice in rectangular slice mode (when rect_slice_flag is equal to 1) For the case where the subpicture is a subpicture, the picture-level slice index for each slice of each subpicture is used. The coefficient is derived, and the derived value is used to derive the number of CTUs in each slice. 2. Sub-picture level slice indices shall be defined / derived in the following way: can be done. a. In one example, the slice index at the subpicture level is “rect_slice When ce_flag is equal to 1, a list of slices within the subpicture in their decoding order is defined as "the index of a slice into b. Alternatively, the slice index at the subpicture level is "rect_sli Slice index for subpicture slice list when ce_flag is equal to 1 The variable SubpicLevelS derived by Equation 32 (similar to the first embodiment) is sliceIdx[i], where i is the picture-level slice index of the slice. is defined as " c. As an example, each slice with a particular picture-level slice index is Derive the subpicture index of the image. d. As an example, each slice with a particular picture-level slice index is The sub-picture level slice index of the slice is derived. e. In one example, when rect_slice_flag is equal to 1, the slice address The semantics of the slice is that the slice address is the variable SubpicL derived in Equation 32. Subpicture level slice index of the slice specified by levelSliceIdx[i] index (e.g., as in embodiment 1), i is the picture-level slice of that slice. It is defined as the "index". 3. The subpicture-level slice index of a slice is the first subpicture containing that slice. The subpicture level of each slice is assigned to the slice in the first subpicture. The slice index is an array indexed by the picture-level slice index. In the column (for example, SubpicLevelSliceIdx[i] in the first embodiment) It may be stored. a. As an example, the slice index at the subpicture level is a non-negative integer. . b. As an example, the slice index value of a subpicture level slice is 0. That's all. c. In one example, the subpicture level slice index value of a slice is greater than N. where N is the number of slices in the subpicture. d. As an example, the first sub-picture level slice of the first slice (slice A) The index (denoted as subIdxA) is the first slice and the second slice (slice B). are in the same subpicture but are different, the second subpicture of the second slice (slice B) It must be different from the picture-level slice index (denoted as subIdxB). e. In one example, the first subpicture of the first slice (slice A) in the first subpicture The slice index (denoted as subIdxA) of the image level is the same as the first subpicture. The slice index of the second subpicture level of the second slice (slice B) in the If IdxA is smaller than IdxB, then IdxA is smaller than IdxB. and idxB represent the slice index occupying the entire screen (a). Here, idxA is the slice idxA is the picture-level slice index of slice A, and idxB is the picture-level slice index of slice B. (sliceIdx, etc.). f. As an example, the first subpicture of the first slice (slice A) in the first subpicture The slice index (denoted as subIdxA) of the subpicture level is the same as the first subpicture. The slice index (s ubIdxB), slice A precedes slice B in decoding order. . g. As an example, a slice index at the sub-picture level in a sub-picture is derived based on the picture-level slice index (e.g., sliceIdx). It is served. 4. Subpicture-level slice index and picture-level slice index within a subpicture We propose to derive a mapping function / table for slice indices. a. For example, the two-dimensional array PicLevelSliceIdx[subPicId x][SubPicLevelSliceIdx] is the subpicture level within the subpicture. Maps bell slice indices to picture-level slice indices. where PicLevelSliceIdx is the picture level of the slice. slice index, subPicIdx is the subpicture index, SubPi cLevelSliceIdx is the subpicture level slice of the subpicture slice Indicates the index. i. In one example, the array NumSlicesInSubpic[subPicIdx] is used to derive PicLevelSliceIdx, and NumSlicesInSub pic[subPicIdx] is the subpicture with index equal to subPicIdx. Indicates the number of slices in the chart. 1) For example, NumSlicesInSubpic[subPicIdx] and PicLevelSliceIdx[subPicIdx][SubPicLevel SliceIdx] lists all slices in picture-level slice index order. It is scanned and derived in one process. a. NumSlicesInSubpic[subPicIdx] is the number of subpics before processing. is set equal to 0 for all valid subPicIdx of b. When checking a slice with picture level index S, If it is in a subpicture with subpicture index P, then PicLevelS Let liceIdx[P][NumSlicesInSubpic[P]] be S, then N umSlicesInSubpic[P] to NumSlicesInSubpic[P] I'll give it +1. ii. In one example, SliceIdxInPic[subPicIdx][SubP icLevelSliceIdx] to find the picture-level slice index (e.g. picLevelSliceIdx) and use it to The number and / or addresses of CTBs in a slice are derived during analysis of the data. 5. In the conformance bitstream, one tile may contain two or more subpictures. It is required that the 6. Slice A is inside tile A but smaller than tile A, and slice B is inside tile B. If tile A is inside but smaller than tile B, and tile A and tile B are different, then one subpicture It is controversial that slice A and slice B cannot contain two slices. Required in the performance bitstream. 7. The tile and / or slice division information of a picture is included in the associated picture header. It is proposed to signal this. In one example, tile and / or slice division information of a picture is signaled in the PPS. whether it is signaled in the associated PPS or signaled in the associated picture header. do. b. In one example, the tile and / or slice division information of a picture is stored in the associated picture. It is signaled whether it is in the header. i. As an example, the tile and / or slice division information of a picture is stored in the associated PP If signaled in both S and the associated picture header, The known tile and / or slice division information of the picture will be used. ii. As an example, the tile and / or slice division information of a picture may be stored in the associated P A picture signaled in a PPS if it is signaled in both the PS and the associated picture header The tile and / or slice division information of the image is used. c. For example, in a video unit at a level higher than a picture (such as SPS) , tile and / or slice division information of a picture is signaled in the associated PPS. signalled in the associated picture header. The number will be notified. 8. When dividing the related picture into slices in non-rectangular mode, the Signal slice division information in the video unit (e.g., in the PPS and / or picture header) Propose to notify. As an example, if the associated picture is sliced ​​in non-rectangular mode, Information indicating the number of slices (e.g., num_slices_in_pic_minus1) It may be signaled by a higher-level video unit. b. As an example, if the associated picture is divided into slices with non-rectangular modes: the index (or block unit index) of the first block unit of the slice in the higher video unit. For example, the block unit is C It may be a TU or a tile. c. As an example, if the relevant picture is sliced ​​in non-rectangular mode: , provides information to indicate the number of block units of a slice in a higher video unit For example, the block unit may be a CTU or a tile. d. In one example, when the associated picture is divided into slices with non-rectangular modes , slice division information (e.g., num_tiles_in_slice_minus1) is not signaled in the slice header. e. As an example, if the relevant picture is divided into slices in non-rectangular mode: , the slice index is signaled in the slice header. i. As an example, slice_address is used when the associated picture is in non-rectangular mode. If the image is divided into slices by the image level, it is interpreted as a picture-level slice index. do. f. In one example, when the associated picture is divided into slices with non-rectangular modes , partition information of each slice in the picture (index of the first block unit and / or The number of block units, etc. may be signaled in order at the higher video unit. i. As an example, if the relevant picture is divided into slices in non-rectangular mode, In this case, even if the slice index is signaled for each slice of the higher-level video unit, good. ii. As an example, the partitioning information for each slice is stored in the slice index. The signals are sent in ascending order. 1) For example, the division information for each slice is 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. iii. As an example, the partitioning information for each slice is stored in the slice index. The signals are sent in descending order of the boxes. 1) For example, the division information for each slice is: slice S-2, slice S-1, ..., slice K+1, slice K, slice K-1, ..., slice 1, slice 0, K is the slice index, and S is the number of slices in the picture. iv. As an example, the relevant picture is divided into slices in a non-rectangular mode. In this case, the index of the first block unit for the slice is the upper video unit. Sometimes the signal is not sent. 1) For example, the first The block unit index is inferred to be 0. 2) For example, slice K (slice with slice index equal to K, K>0 )'s first block unit index is

number

number

number

number

[0083] 6. Implementation In the following examples, additions are indicated in bold, underlined, and italicized text. The deleted part is marked in [].

[0084] 6.1. Example 1: Example of changing slice index at subpicture level 3 Definition

[0085] [ka]

[0086] 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing …

[0087] [ka]

[0088] for(j=0;j<=sps_num_subpics_minus1;j++) NumSlicesInSubpic[j]=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ){ posX=CtbAddrInSlice[i][0]%PicWidthInCt bsY posY=CtbAddrInSlice[i][0] / PicWidthInCt bsY for(j=0;j<=sps_num_subpics_minus1;j++) { if((posX>=subpic_ctu_top_left_x[j])&& (32) (posX <subpic_ctu_top_left_x[j]+subp ic_width_minus1[j]+1)&& (posY>=subpic_ctu_top_left_y[j])&& (posY <subpic_ctu_top_left_y[j]+subp ic_height_minus1[j]+1)){ [ka] NumSlicesInSubpic[j]++ } } } …

[0089] 7.4.8.1 General slice header semantics ... slice_address specifies the slice address of the slice. In this case, the value of slice_address is inferred to be equal to 0. e_flag is 1 and NumSlicesInSubpic[CurrSubpicIdx When ] is 1, the value of slice_address is inferred to be 0. If rect_slice_flag is equal to 0, the following applies: - The slice address is the raster scan tile index. - The length of slice_address is Ceil(Log2(NumTilesIn Pic)) bit. - slice_address is a value between 0 and NumTilesInPic-1 It should be within range. Otherwise (rect_slice_flag is equal to 1), the following applies: can be. [ka] - The length of slice_address is Ceil(Log2(NumSlicesI nSubpic[CurrSubpicIdx])) bits. - The value of slice_address ranges from 0 to NumSlicesInSubpic[ CurrSubpicIdx]-1. The requirements for bitstream conformance are that the following constraints apply: - rect_slice_flag is equal to 0 or subpic_info_pr If esent_flag is equal to 0, the value of slice_address must be the same as Any other coded slice NAL unit in the coded picture slice_address must not be equal to the value of slice_address. - Otherwise, slice_subpic_id and slice_address The set of values ​​is the same as any other coded sequence in the same coded picture. slice_subpic_id and slice_address of the slice NAL unit The value pair must not be equal. - The shape of a slice of a picture is such that each CTU, when decoded, has its entire left boundary and its most The entire upper boundary is the boundary of one picture or contains the boundary of a previously decoded CTU. It must be. ... num_tiles_in_slice_minus1 plus 1, if present, Specifies the number of tiles in a slice. num_tiles_in_slice_minus1 The value should be in the range 0 to NumTilesInPic-1. The variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice and for i in the range 0 to NumCtusInCurrSlice-1 (inclusive) , a list Ct specifying the picture raster scan address of the ith CTB in the slice bAddrInCurrSlice[i] is derived as follows: if(rect_slice_flag){ [ka] [[for(j=0;j <CurrSubpicIdx;j++) picLevelSliceIdx+=NumSlicesInSubpic[j] }] NumCtusInCurrSlice=NumCtusInSlice[picLe velSliceIdx] for(i=0;i <NumCtusInCurrSlice;i++) CtbAddrInCurrSlice[i]=CtbAddrInSlice[p icLevelSliceIdx][i] (117) }else{ NumCtusInCurrSlice=0 for(tileIdx=slice_address;tileIdx<=slic e_address+num_tiles_in_slice_minus1;tile Idx++){ tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns for(ctbY=tileRowBd[tileY];ctbY <tileRow Bd[tileY+1];ctbY++){ for(ctbX=tileColBd[tileX];ctbX <tileCo lBd[tileX+1];ctbX++){ CtbAddrInCurrSlice[NumCtusInCurrSlic e]=ctbY*PicWidthInCtb+ctbX NumCtusInCurrSlice++ } } } } …

[0090] 6.2. Example 2: Signaling Slices in PPS for Non-Rectangular Mode 7.3.2.4 Picture parameter set RBSP syntax

[0091] [Table 19] [Table 20]

[0092] 7.3.7.1 General Slice Segment Header Syntax

[0093] [Table 21]

[0094] 7.4.3.4 Picture parameter set RBSP semantics num_slices_in_pic_minus1 plus 1 refers to the PPS, each Specifies the number of [[rectangular]] slices in the picture. num_slices_in_pic The value of _minus1 ranges from 0 to MaxSlicesPerPicture-1 (both (including the edge), and MaxSlicesPerPicture shall be as specified in Annex A. If no_pic_partition_flag is 1, num_slices The value of _in_pic_minus1 is inferred to be equal to 0. [ka] …

[0095] 7.4.8.1 General slice header semantics … slice_address specifies the slice address of the slice. In this case, the value of slice_address is inferred to be equal to 0. e_flag is 1 and NumSlicesInSubpic[CurrSubpicIdx When ] is 1, the value of slice_address is inferred to be 0. If e_flag is 0 and NumSlicesInPic is 1, slice_ The value of address is inferred to be 0. If rect_slice_flag is equal to 0, the following applies: [ka] Otherwise (rect_slice_flag is equal to 1), the following applies: can be. - The slice address is the sub-picture level slice index of the slice. - The length of slice_address is Ceil(Log2(NumSlicesI nSubpic[CurrSubpicIdx])) bits. - The value of slice_address ranges from 0 to NumSlicesInSubpic[ CurrSubpicIdx]-1. The requirements for bitstream conformance are that the following constraints apply: - [[rect_slice_flag is equal to 0 or subpic_info_ If present_flag is equal to 0, the value of slice_address is the same Any other coded slice NAL unit in the coded picture It must not be equal to the slice_address value of the bit. [ka] - The shape of a slice of a picture is such that each CTU, when decoded, has its entire left boundary and its most The entire upper boundary is the boundary of one picture or contains the boundary of a previously decoded CTU. It must be. … The variable NumCtusInCurrSlice that specifies the number of CTUs in the current slice and for i in the range 0 to NumCtusInCurrSlice-1 (inclusive) , a list Ct specifying the picture raster scan address of the ith CTB in the slice bAddrInCurrSlice[i] is derived as follows: if(rect_slice_flag){ picLevelSliceIdx=slice_address for(j=0;j <CurrSubpicIdx;j++) picLevelSliceIdx+=NumSlicesInSubpic[j] NumCtusInCurrSlice=NumCtusInSlice[picLe velSliceIdx] for(i=0;i <NumCtusInCurrSlice;i++) CtbAddrInCurrSlice[i]=CtbAddrInSlice[p icLevelSliceIdx][i] (117) }else{ NumCtusInCurrSlice=0 [ka] tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns for(ctbY=tileRowBd[tileY];ctbY <tileRow Bd[tileY+1];ctbY++){ for(ctbX=tileColBd[tileX];ctbX <tileCo lBd[tileX+1];ctbX++){ CtbAddrInCurrSlice[NumCtusInCurrSlic e]=ctbY*PicWidthInCtb+ctbX NumCtusInCurrSlice++ } } } }

[0096] 6.3. Example 3: Signal tiles adjusted to picture dimensions 7.3.2.4 Picture parameter set RBSP syntax

[0097] [Table 22] [Table 23]

[0098] 6.4. Embodiment #4: tile_column_width_minus1 and ti Semantic Example 1 for le_row_height_minus1 7.4.3.4 Picture parameter set RBSP semantics … [ka] [ka] …

[0099] 6.5. Embodiment #5: tile_column_width_minus1 and ti Semantic Example 2 for le_row_height_minus1 7.4.3.4 Picture parameter set RBSP semantics … [ka] …

[0100] 6.6. Embodiment #6: Example of Derivation of CTU in Slice 6.5 Scanning Process 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing … For rectangular slices, i goes from 0 to num_slices_in_pic_minus1 NumCtusInSlice[i] is the list of the range (inclusive) of Specifies the number of CTUs in, where i ranges from 0 to num_slices_in_pic_min The list SliceTopLeftTileIdx[i] of the range of us1 (inclusive) is Specifies the index of the top-left tile of the slice, j ranges from 0 to NumCtusInSli The jth CTB picture in the i-th slice in the range ce[i]-1 (inclusive) Specifies the raster scan address and is derived as follows: if(single_slice_per_subpic_flag){ for(i=0;i<=sps_num_subpics_minus1;i++) NumCtusInSlice[i]=0 for(i=0;i <PicSizeInCtbsY;i++){ sliceIdx=subpic_info_present_flag?CtbT oSubpicIdx[i]:0 CtbAddrInSlice[sliceIdx][NumCtusInSlic e[sliceIdx]]=i NumCtusInSlice[sliceIdx]++ } }else{ tileIdx=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ) NumCtusInSlice[i]=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ){ SliceTopLeftTileIdx[i]=tileIdx tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns if(i==num_slices_in_pic_minus1){ slice_width_in_tiles_minus1[i]=NumTil eColumns-1-tileX slice_height_in_tiles_minus1[i]=NumTi leRows-1-tileY } if(slice_width_in_tiles_minus1[i]==0&& slice_height_in_tiles_minus1[i]==0){ (29 ) ctbY=tileRowBd[tileY] for(j=0;j<NumSlicesInTile[i]-1;j++){ AddCtbsToSlice(i,tileColBd[tileX],ti leColBd[tileX+1], ctbY,ctbY+SliceHeightInCtusMinus1 i]+1) ctbY+=SliceHeightInCtusMinus1[i]+1 i++ } AddCtbsToSlice(i,tileColBd[tileX],til eColBd[tileX+1],ctbY,tileRowBd[tileY+1]) }else for(j=0;j<=slice_height_in_tiles_minu s1[i];j++) for(k=0;k<=slice_width_in_tiles_minu s1[i];k++) AddCtbsToSlice(i,tileColBd[tileX+k] ,tileColBd[tileX+k+1], tileRowBd[tileY+j],tileRowBd[tileY +j+1])

Chem.

[0101] 6.7. Embodiment #7: Notification of MER Size 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0102] [Table 24]

[0103] 7.4.3.3 Sequence Parameter Set RBSP Semantics log2_parallel_merge_level_minu_log2_min cb_coding_block_size_minus2+2 is the variable Log2Par Specifies the value of MrgLevel, which determines the distribution of spatial merge candidates as specified in 8.5.2.3. Raw processing and motion vectors in sub-block merge mode as specified in 8.5.5.2 and the derivation of reference indices, the history-based motion vectors in Section 8.5.2.1 Used to control the call to update the log predictor list. The value of llel_merge_level_minus_log2_mincb ranges from 0 to CtbLog2SizeY-log2_min_luma_coding_block_ The range is inclusive of size_minus2-2. Variable Log2ParMrgLevel is derived as follows: Log2ParMrgLevel=log2_parallel_merge_leve l_minus2+log2_min_luma_coding_block_size _minus2+2 (68)

[0104] 6.8. Embodiment #8 Signaling of Rectangular Slices 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing ... Conversion from CTB address to subpicture index in picture raster scan ctb in the range 0 to PicSizeInCtbsY_1 (inclusive) that specifies The list for AddrR, ctbToSubpicIdx[ctbAddrRs], is as follows: It is derived as follows: for(ctbAddrRs=0;ctbAddrRs <PicSizeInCtbsY ;ctbAddrRs++){ posX=ctbAddrRs%PicWidthInCtbsY posY=ctbAddrRs / PicWidthInCtbsY ctbToSubpicIdx[ctbAddrRs]=-1 for(i=0;ctbToSubpicIdx[ctbAddrRs]<0&&i< =sps_num_subpics_minus1;i++){ (29) if((posX>=subpic_ctu_top_left_x[i])&& (posX <subpic_ctu_top_left_x[i]+subpi c_width_minus1[i]+1)&& (posY>=subpic_ctu_top_left_y[i])&& (posY <subpic_ctu_top_left_y[i]+subpi c_height_minus1[i]+1)) ctbToSubpicIdx[ctbAddrRs]=i } } [ka] if(single_slice_per_subpic_flag) { for(i=0;i<=sps_num_subpics_minus1;i++) NumCtusInSlice[i] = 0 for (i = 0; i < PicSizeInCtbsY; i++) { sliceIdx = ctbToSubpicIdx[i] CtbAddrInSlice[sliceIdx][NumCtusInSlic e[sliceIdx]] = i NumCtusInSlice[sliceIdx]++ } } else { tileIdx = 0 for (i = 0; i <= num_slices_in_pic_minus1; i++ ) NumCtusInSlice[i] = 0 for (i = 0; i <= num_slices_in_pic_minus1; i++ ) { SliceTopLeftTileIdx[i] = tileIdx tileX = tileIdx % NumTileColumns tileY = tileIdx / NumTileColumns

Chem.

Chem.

[0105] [Table 25]

[0106] 7.4.3.4 Picture Parameter Set Semantics ... If tile_idx_delta_present_flag is equal to 0, til Specifies that the e_idx_delta[i] syntax element is not included in the PPS, and All pictures that reference the rectangle slice rows and rectangle slice columns are arranged in slice raster order. If tile_idx_delta_present_flag is equal to 1, If the PPS is All rectangular slices of the referenced picture are sorted by tile_idx_d with increasing value of i. Specifies that the order indicated by elta[i] is specified. If not present, tile_i The value of dx_delta_present_flag is inferred to be 0. slice_width_in_tiles_minus1[i] plus 1 is the ith slice_width_in_t Specifies the width of a rectangular slice of the The value of iles_minus1[i] ranges from 0 to NumTileColumns-1. It should be within range. i is less than num_slices_in_pic_minus1 and NumTi If leColumns is equal to 1, slice_width_in_tiles_m The value of inus1[i] is inferred to be equal to 0. slice_height_in_tiles_minus1[i] plus 1 is nu If m_exp_slices_in_tile[i] is equal to 0, the ith rectangular slic slice_height_in_tiles Specifies the height of the slice in tile rows. The value of _minus1[i] should be in the range 0 to NumTileRows-1. It is. i is less than num_slices_in_pic_minus1 and slice If _height_in_tiles_minus1[i] does not exist, NumTi leRows==1?0:slice_height_in_tiles_minus1 It is inferred to be equal to [i-1]. num_exp_slices_in_tile[i] is the number of tiles containing the ith slice. Specifies the number of slice heights provided explicitly for slices in a file (i.e. That is, the tile whose tile index is equal to SliceTopLeftTileIdx[i]. The value of num_exp_slices_in_tile[i] ranges from 0 to RowHe ight[SliceTopLeftTileIdx[i] / NumTileColumn ns]-1 (inclusive). If not present, num_exp_slices The value of _in_tile[i] is inferred to be equal to 0. [ka] [ka] ...

[0107] 6.9. Embodiment #9: Signaling of Rectangular Slices 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing ... If rect_slice_flag is equal to 1, the CTU in the i-th slice The list NumCtusInSlice[i] (i is from 0 to num_sli ces_in_pic_minus1 inclusive), the first CT in the slice A list specifying the tile index of the tile containing U. SliceTopLeftTil eIdx[i] (i ranges from 0 to num_slices_in_pic_minus1) (inclusive), the picture raster scan address of the jth CTB in the ith slice matrix CtbAddrInSlice[i][j] (i ranges from 0 to num_slic ces_in_pic_minus1 inclusive, j is between 0 and NumCtusIn Slice[i]-1 inclusive), the tile containing the i-th slice (i.e., (tile whose tile index is equal to SliceTopLeftTileIdx[i]) The variable NumSlicesInTile[i] that specifies the number of slices in It is derived. if(single_slice_per_subpic_flag){ for(i=0;i<=sps_num_subpics_minus1;i++) NumCtusInSlice[i]=0 for(i=0;i <PicSizeInCtbsY;i++){ sliceIdx=ctbToSubpicIdx[i] CtbAddrInSlice[sliceIdx][NumCtusInSlic e[sliceIdx]]=i NumCtusInSlice[sliceIdx]++ } }else{ tileIdx=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ) NumCtusInSlice[i]=0 for(i=0;i<=num_slices_in_pic_minus1;i++ ){ SliceTopLeftTileIdx[i]=tileIdx tileX=tileIdx%NumTileColumns tileY=tileIdx / NumTileColumns if(i<num_slices_in_pic_minus1){ sliceWidthInTiles[i]=slice_width_in_t iles_minus1[i]+1 sliceHeightInTiles[i]=slice_height_in _tiles_minus1[i]+1 }else{ sliceWidthInTiles[i]=NumTileColumns-t ileX sliceHeightInTiles[i]=NumTileRows-til eY NumSlicesInTile[i]=1 } if(sliceWidthInTiles[i]==1&&sliceHeigh tInTiles[i]==1){ (30) if( num_exp_slices_in_tile[i]==0){ NumSlicesInTile[i]=1 sliceHeightInCtus[i]=RowHeight[Slice TopLeftTileIdx[i] / NumTileColumns } else { remainingHeightInCtbsY = RowHeight[Sli ceTopLeftTileIdx[i] / NumTileColumns] [[for (j = 0; j < num_exp_slices_in_tile[i ; j++) {}]

Chem.

Chem.

化

Chem.

[0108] 6.10. Embodiment #10: Subpicture and Tile Signaling 6.5.1 CTB Raster Scan, Tile Scan, and Subpicture Scan Processing The variable NumTileColumns that specifies the number of tile columns, and the i-th column in CTB units. A list of colWidth[i] (i is a number from 0 to NumTile) specifying the width of the first tile column. Columns-1 (inclusive range) is derived as follows: remainingWidthInCtbsY=PicWidthInCtbsY [ka] colWidth[i]=tile_column_width_minus1[i] +1 remainingWidthInCtbsY-=colWidth[i] } uniformTileColWidth=tile_column_width_mi nus1[num_exp_tile_columns_minus1]+1 (23) while(remainingWidthInCtbsY>=uniformTile ColWidth){ colWidth[i++]=uniformTileColWidth remainingWidthInCtbsY-=uniformTileColWi dth } if(remainingWidthInCtbsY>0) colWidth[i++]=remainingWidthInCtbsY NumTileColumns=i The variable NumTileRows that specifies the number of tile rows, and the jth tile in CTB units. A list of j in the range 0 to NumTileRows_1 (inclusive) that specifies the row height. The row height [j] is derived as follows: remainingHeightInCtbsY=PicHeightInCtbsY [ka] RowHeight[j]=tile_row_height_minus1[j]+ 1 remainingHeightInCtbsY-=RowHeight[j] } uniformTileRowHeight=tile_row_height_min us1[num_exp_tile_rows_minus1]+1 (24) while(remainingHeightInCtbsY>=uniformTil eRowHeight){ RowHeight[j++]=uniformTileRowHeight remainingHeightInCtbsY-=uniformTileRowH eight } if(remainingHeightInCtbsY>0) RowHeight[j++]=remainingHeightInCtbsY NumTileRows=j 7.3.2.3 Sequence Parameter Set RBSP Syntax

[0109] [Table 26]

[0110] 7.3.2.4 Picture parameter set RBSP syntax

[0111] [Table 27]

[0112] 7.4.3.4 Picture Parameter Set Semantics ... [ka] ...

[0113] FIG. 7 illustrates an exemplary video processing system 1 in which various techniques disclosed herein may be implemented. 900. Various implementations may be implemented using components of the system 1900. The system 1900 may include some or all of the following: The video content may include an input unit 1902. may be received as multi-component pixel values, e.g., 8 or 10 bit, or The input unit 1902 may receive the network It may refer to a network interface, a peripheral bus interface, or a memory interface. Examples of network interfaces are Ethernet, PON (registered trademark), Wired interfaces such as Passive Optical Network (Trademark), and wireless interfaces such as Wi-Fi or cellular interfaces Includes

[0114] The system 1900 may implement various coding or encoding methods described herein. The coding component 1904 may include a coding component 1904 that can The component 1904 encodes the average bit rate of the video from the input unit 1902. 1904 to generate a coded representation of the video. Therefore, this coding technology is called video compression or video transcoding technology. The output of the coding component 1904 is sometimes called component 1. As represented by 906, it may be stored or transmitted via a connected communication The input unit 1902 may receive, store, or transmit video. The bitstream (or coding) representation is used by the component 1908. 19. The image data is then converted into pixel values ​​or displayable images that are sent to the display interface 1910. The process of generating a user-viewable video from a bitstream representation is Furthermore, certain image processing operations are sometimes called "coding." Although we refer to "coding" operations or tools, the coding tools or operations are encoders and their counterparts. Corresponding decoding tools or operations that reverse the results of the coding are performed by the decoder. It will be understood that

[0115] An example of a peripheral bus interface or display interface is USB (registered trademark). Universal Serial Bus) or HDMI (registered trademark; High Delay Finiyion Multimedia Interface) or DisplayPort An example of a storage interface is SATA (Serial ATA) Advanced Technology Attachment), PCI, IDE The technology described herein is applicable to mobile phones, laptops, smartphones, and other devices. Smartphones or other devices capable of digital data processing and / or video display The present invention may be implemented in a variety of electronic devices.

[0116] 8 is a block diagram of a video processing device 3600. The device 3600 is The device 3600 may be used to implement one or more of the methods described above. It may be implemented on tablets, computers, Internet of Things (IoT) receivers, etc. The device 3600 includes one or more processors 3602, one or more memories 3604, and and video processing hardware 3606. 2 may be configured to implement one or more of the methods described herein. 3604 are used to implement the methods and techniques described herein. It may also be used to store data and code. may be used to implement the techniques described herein in hardware circuitry.

[0117] FIG. 10 illustrates an example video coding system 100 that may utilize techniques of this disclosure. FIG.

[0118] As shown in FIG. 10, the video coding system 100 includes a source device 110 and The source device 110 may include a destination device 120. The source device 110 may include a destination device 120. The destination device 12 generates the data and may also be called a video encoding device. 0 may decode the encoded video data generated by source device 110. , may be referred to as a video decoding device.

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

[0120] The video source 112 may be a source such as a video capture device, a video content provider, or the like. Interface for receiving video data from a video recorder and / or for generating video data a computer graphics system for creating a The video data may include one or more pictures. The decoder 114 encodes the video data from the video source 112 and generates a bitstream. A bitstream is a sequence of bits that form a coded representation of video data. The bitstream may contain coded pictures and associated A coded picture may contain data that is coded for the picture. Associated data includes sequence parameter sets, picture The I / O interface 116 may include parameter sets and other syntactic structures. may include a modulator-demodulator (modem) and / or a transmitter. is transmitted to the destination device via the network 130a and the I / O interface 116. The encoded video data may be sent directly to destination device 120. It may be stored on a storage medium / server 130b for access.

[0121] The destination device 120 includes an I / O interface 126, a video decoder 124, and and a display device 122.

[0122] The I / O interface 126 may include a receiver and / or a modem. The interface 126 receives data from the source device 110 or storage medium / server 130b. The video decoder 124 may obtain the encoded video data from the The display device 122 may then display the decoded video data to the user. The display device 122 may be integrated with the destination device 120 or may be an external external to the destination device 120 configured to interface with the display device It's okay to have it.

[0123] The video encoder 114 and the video decoder 124 are HEVC (High Efficiency Video Codec) iency Video Coding) standard, VVM (Versatile Video Coding) standard, video compression standards, such as the IEEE 802.11b (International) Standards for Video Coding, and other current and / or future standards; It may operate according to the case.

[0124] FIG. 11 is a block diagram showing an example of a video encoder 200. 200 may be the video encoder 114 in the system 100 shown in FIG. stomach.

[0125] Video encoder 200 may be configured to perform any or all of the techniques of this disclosure. In the example of FIG. 11, the video encoder 200 may include multiple functional components. The techniques described in this disclosure provide a method for implementing a video encoder 200 between various components of the video encoder 200. In some examples, the processor may be shared by any of the techniques described in this disclosure. It may be configured to do either or all of the above.

[0126] The functional components of the video encoder 200 include a division unit 201 and a mode selection unit 202. unit 203, motion estimation unit 204, motion compensation unit 205 and intra prediction unit 206. A prediction unit 202 may include a residual generation unit 206, a residual generation unit 207, and a transform unit 208, a quantization unit 209, an inverse quantization unit 210, and an inverse transform unit 211. 11, a reconstruction unit 212, a buffer 213, and an entropy coding unit 21 4 and may include.

[0127] In other examples, video encoder 200 may have more, fewer, or different functions. In one example, the prediction unit 202 may include an intra-block An IBC unit may contain at least one reference Prediction is performed in IBC mode where the picture is the picture in which the current video block is located. That's fine.

[0128] Furthermore, some components such as a motion estimation unit 204 and a motion compensation unit 205 The components may be highly integrated, but for purposes of illustration, are shown separately in the example of FIG. It has been done.

[0129] The division unit 201 may divide a picture into one or more video blocks. The video encoder 200 and the video decoder 300 support a variety of video block sizes. You may also use it.

[0130] The mode selection unit 203 may select, for example, an intra or inter mode based on the error result. and select one of the coding modes The resulting block is fed to a residual generation unit 207 to generate residual block data; 212 to be used as a reference picture. In some examples, the mode selection unit 203 may select inter prediction. Combination Inverse Prediction (CIIP) is a method for predicting the signal and the intra-prediction signal. of Intra and Inter Prediction modes can be selected. In the case of inter prediction, the mode selection unit 203 selects a motion vector for the block. The resolution (e.g., sub-pixel or integer pixel accuracy) may be selected.

[0131] A motion estimation unit 204 performs inter prediction on the current video block. compares the current video block with one or more reference frames from buffer 213. The motion compensation unit may generate motion information for the current video block by The buffer 205 receives a picture from the buffer 213 other than the picture associated with the current video block. Based on the motion information of the picture and the decoded samples, a predicted image is calculated for the current image block. The block may be determined.

[0132] The motion estimation unit 204 and the motion compensation unit 205 may, for example, is an I-slice, a P-slice, or a B-slice. Different operations may be performed on the image blocks.

[0133] In some examples, the motion estimation unit 204 performs a unidirectional motion estimation on the current video block. To perform forward prediction, motion estimation unit 204 uses a reference video block for the current video block. For a check, the reference picture in list 0 or list 1 may be searched. The determination unit 204 determines the reference video block and the relationship between the current video block and the reference video block. and a motion vector indicating the spatial displacement between the reference pixels in list 0 or list 1. The motion estimation unit 204 may generate a reference index that indicates the motion vector. The motion information of the current video block is then added to the frame, prediction direction indicator, and motion vector. The motion compensation unit 205 may output the motion information of the current video block as A prediction video block for the current block may be generated based on the reference video block.

[0134] In another example, motion estimation unit 204 may bidirectionally predict the current video block. Preferably, the motion estimation unit 204 selects a reference picture from the list 0 for the current video block. The reference picture in List 1 may be searched for to lock the reference picture block. , and may search for another reference video block for the current video block in Motion estimation unit 204 uses the reference blocks in List 0 and List 1, which contain reference video blocks. a reference index indicating the reference picture and a distance between the reference video block and the current video block The motion estimation unit 204 may generate a motion vector that indicates the spatial displacement of the current The reference index and motion vector of the video block are added to the motion information of the current video block. The motion compensation unit 205 may output the motion information of the current video block as A prediction video block for the current video block may be generated based on the reference video block. stomach.

[0135] In some examples, the motion estimation unit 204 may generate motion vectors for the decoder's decoding process. The full set of information may be output.

[0136] In some examples, the motion estimation unit 204 may generate a full set of motion information for the current picture. Rather, motion estimation unit 204 may output a motion vector of another video block. The motion information of the current video block may be signaled by referring to the motion information. The estimation unit 204 calculates the motion information of the current video block by comparing it with the motion information of the neighboring video blocks. may be determined to be sufficiently similar to

[0137] In one example, the motion estimation unit 204 calculates the syntax associated with the current video block. In the structure, the current video block is shown to have the same motion information as another video block. The value shown to the image decoder 300 may be:

[0138] In another example, the motion estimation unit 204 may estimate the structure associated with the current video block. In the sentence structure, there is another video block and MVD (Motion Vector Difference) The motion vector differential may identify the motion vector of the current video block. The video decoder 300 indicates the difference between the motion vector and the motion vector for the indicated video block. The motion vector of the designated video block is used to calculate the current video block using the motion vector difference. The motion vectors of the image blocks may be determined.

[0139] As mentioned above, video encoder 200 may predictively signal motion vectors. Two examples of predictive signaling techniques that may be implemented by video encoder 200 are AMV P (Advanced Motion Vector Prediction) and Includes message mode signaling.

[0140] Intra prediction unit 206 may perform intra prediction on the current video block. If intra prediction unit 206 intra predicts the current video block, The prediction unit 206 uses the decoded samples of other video blocks in the same picture. Based on the current video block, prediction data for the current video block may be generated. The prediction data for a block may include predicted video blocks and various syntax elements. stomach.

[0141] The residual generation unit 207 generates a predicted residual of the current video block from the current video block. By subtracting the video blocks (e.g., indicated by a minus sign), Residual data may be generated for the current video block. The residual image data corresponds to different sample components of the samples in the current image block. It may contain blocks.

[0142] In another example, for example in skip mode, the residual for the current video block The data may be missing and the residual generation unit 207 may not perform the subtraction operation.

[0143] Transform processing unit 208 generates a residual video block associated with the current video block. Transform one or more images for the current video block by applying one or more transformations to the A number of transform coefficient image blocks may be generated.

[0144] Transform processing unit 208 calculates the transform coefficients associated with the current video block. After generating the block, quantization unit 209 calculates the one or more is associated with the current video block based on the values ​​of multiple quantization parameters (QP). The resulting transform coefficient video block may be quantized.

[0145] Inverse quantization unit 210 and inverse transform unit 211 perform inverse quantization on the transform coefficient video block. Quantization and inverse transformation are applied to reconstruct the residual video block from the transform coefficient video block. The reconstruction unit 212 may reconstruct one or more Add the reconstructed residual video block to the corresponding sample from the predicted video block, The reconstructed image block associated with the current block for storage in F213 may be generated.

[0146] After reconstruction unit 212 reconstructs the video blocks, To reduce filtering artifacts, a loop filtering operation may be performed.

[0147] The entropy coding unit 214 is a component of the other functional components of the video encoder 200. The entropy encoding unit 214 may receive data from Then, one or more entropy coding operations are performed to generate the entropy coded data. and may output a bitstream containing entropy-encoded data. .

[0148] FIG. 12 is a block diagram showing an example of a video decoder 300. 0 may be the video decoder 114 in the system 100 shown in FIG.

[0149] The video decoder 300 is configured to perform any or all of the techniques of this disclosure. In the embodiment of FIG. 12, the video decoder 300 includes multiple functional components. The techniques described in this disclosure include shared memory among various components of video decoder 300. In some examples, the processor may implement any of the techniques described in this disclosure. Alternatively, the device may be configured to perform all of the above.

[0150] In the example of FIG. 12, the video decoder 300 includes an entropy decoding unit 301, a motion A compensation unit 302, an intra prediction unit 303, an inverse quantization unit 304, an inverse transform unit 306, an inverse The video decoder 301 includes a video decoder unit 305, a reconstruction unit 306, and a buffer 307. The encoder 300 may, in some examples, be implemented using the same code as described with respect to the video encoder 200 (FIG. 11). A decoding pass may be performed that is roughly the reverse of the encoding pass.

[0151] The entropy decoding unit 301 retrieves the coded bitstream. The encoded bitstream is the entropy-encoded video data (e.g., video data The entropy decoding unit 301 may include an encoded block of data. The entropy-encoded video data is decoded, and the motion vector is extracted from the entropy-decoded video data. The motion compensation unit 302 receives the motion vector, the motion vector precision, the reference picture list index, and the The motion compensation unit 302 may determine motion information including the frame rate, frame rate, and other motion information. determines such information by running, for example, AMVP and merge modes. That's fine.

[0152] The motion compensation unit 302 may generate motion compensated blocks, possibly performs interpolation based on an interpolation filter. The interpolation filter used has sub-pixel accuracy. An identifier for the router may be included in the syntax element.

[0153] Motion compensation unit 302 is used by video encoder 200 during the encoding of a video block. Interpolated values ​​for sub-integer pixels of the reference block using an interpolation filter such as The motion compensation unit 302 may calculate the motion vector based on the received syntax information. The coder 200 determines the interpolation filter to use and uses this interpolation filter to generate the predicted block. A check may be generated.

[0154] The motion compensation unit 302 compensates for the frames and / or segments of the encoded video sequence. Syntax information to determine the size of the blocks used to encode the Rice, describes how each macroblock of a picture in a coded video sequence is divided the partition information that each partition is coded, the mode that indicates how each partition is coded, and the One or more reference frames (and a reference frame list) for the block, and encoding The decoder may use some of the other information to decode the encoded video sequence.

[0155] The intra prediction unit 303 may, for example, predict the intra frames received in the bitstream. Prediction modes may be used to form a prediction block from spatially adjacent blocks. The inverse quantization unit 303 is provided to the bitstream and the entropy decoding unit 3 Dequantize (i.e., dequantize) the quantized video block coefficients decoded by 01. The inverse transform unit 303 applies the inverse transform.

[0156] The reconstruction unit 306 performs the reconstruction of the residual block and the motion compensation unit 202 or the intra prediction. and the corresponding prediction block generated by unit 303 to form the decoded block. If desired, a block may be formed after the decoded image to remove block artifacts. A deblocking filter may be applied to filter the decoded blocks. The decoded video blocks are stored in a buffer 307, which is used for subsequent motion compensation. provides reference blocks for compensation / intra prediction and is decoded for display on a display device. Generates a video that matches the image.

[0157] Next, preferred solutions are listed in some embodiments.

[0158] The following solutions represent exemplary implementations of the techniques discussed in the previous section (eg, item 1).

[0159] 1. A video processing method (e.g., method 900 depicted in FIG. 9) processes one or more video pictures. converting (902) between a video including the image and a coded representation of the video; , each video picture contains sub-pictures containing one or more slices, and is coded The representation conforms to formatting rules, which define rectangular slides for video pictures. When slice mode is enabled, each slice of each subpicture in the video picture The picture-level slice index for The format rules specify that the data is derived without any signaling in each slice. The number of coding tree units can be derived from the picture-level slice index. It is stipulated that:

[0160] The following solutions illustrate exemplary implementations of the techniques discussed in the previous section (eg, item 2).

[0161] 2. A video processing method comprising: a video including one or more video pictures; and a coded version of the video. Each video picture may contain one or more slices, including converting between the video and image representations. The coded representation, including the subpicture above, conforms to the formatting rules and The matte rule specifies the subpicture level slice index in the coded representation. without signaling the source, based on information in the coded representation It specifies that the slice index can be derived.

[0162] 3. The formatting rules use a rectangular slice structure to separate subpictures. The subpicture level slice index is the number of slices in a subpicture. The method according to Solution 2, specifying that the slice corresponds to an index into the slice.

[0163] 4. The format rule is such that the sub-picture level slice index is a picture The slicing index is derived from a specific value of the level slice index. How to post.

[0164] The following solutions represent exemplary implementations of the techniques discussed in previous sections (e.g., items 5 and 6). .

[0165] 5. A video processing method includes: a video including one or more video pictures; and a coded version of the video. and converting between the two representations, each video picture being composed of one or more sub-pictures and / or or one or more tiles, and the coded representation conforms to formatting rules and is The conversion involves compliance with constraint rules.

[0166] 6. The constraint rule states that a tile must not be included in multiple subpictures. The method of Solution 5, which provides:

[0167] 7. The constraint rule is that one subpicture is a tile that contains two slices. Solution 5 specifies that a slice cannot contain two slices smaller than Law.

[0168] The following solutions represent exemplary implementations of the techniques discussed in previous sections (e.g., items 7 and 8). .

[0169] 8. A video processing method comprising: a video including one or more video pictures; and a coded version of the video. Each video picture may be one or more tiles and / or a The coded representation includes the above slices and conforms to the formatting rules. The bit rule is that one field at the video picture level is used for the slice and the video picture. This specification provides for conveying information about the division of the image into tiles and / or tiles.

[0170] 9. The method according to solution 8, wherein the field comprises a video picture header.

[0171] 10. The method according to solution 8, wherein the field comprises a picture parameter set.

[0172] 11. The format rule defines a slice division into the fields at the video picture level. By including the information, it is possible to omit the slice division information at the slice level. 11. The method according to any of Solutions 8 to 10, wherein

[0173] The following solutions represent exemplary implementations of the techniques discussed in the previous section (eg, item 9).

[0174] 12. A video processing method includes: a video including one or more pictures; and a coded version of the video. This involves converting between the two representations, which may be the smallest divisions of a video picture. The number of slices is a function of whether rectangular division is used to divide this video picture. Follow certain division rules.

[0175] 13. The division rule uses at least two slices for non-rectangular divisions and The method of Solution 12, which provides for using at least one slice for the division method.

[0176] 14. The division rule defines a number of sub-pictures used to divide the video picture. 13. The method according to solution 12, which is also a number and / or a function of a number.

[0177] The following solutions are exemplary implementations of the techniques discussed in previous sections (e.g., items 10 and 11). show.

[0178] 15. An image processing method comprising: the coded representation is in accordance with formatting rules and the formatting rules are such that the coded representation is signaling the video slices based on a top left position; The rule is that the coded representation is based on partition information signaled at the video unit level. The present invention provides for signaling the height and / or width of the video slice in the video stream.

[0179] 16. The format rule is such that the video slice is defined by the format rule. The method according to solution 15, wherein the slices are signaled in the order of the slices specified.

[0180] 17. The image area corresponds to one subpicture, and the image unit level corresponds to one 16. The method of solution 15, corresponding to video pictures.

[0181] The following solutions represent exemplary implementations of the techniques discussed in the previous section (eg, item 12).

[0182] 18. A video processing method comprising: a video including a video picture; and a coded representation of the video. This coded representation conforms to formatting rules, including converting between The formatting rules are as follows: signaling the difference between the tile index of the first tile in the next rectangular slice It is stipulated that the and be omitted.

[0183] 19. The difference is a value obtained by dividing the 0th slice in the video picture by the rectangular slice. The method of solution 18, which can be derived.

[0184] The following solutions represent exemplary implementations of the techniques discussed in the previous section (eg, item 13).

[0185] 20. A video processing method converts between an image and a coded representation of the image. This coded representation complies with the formatting rules and The coding rule is that the relationship between the width of a video picture and the size of a coding tree unit is Signaling of information used to derive the number of columns or rows of tiles in a video picture It provides for the control of knowledge.

[0186] 21. The format rule is such that the width of the video picture is equal to the coding tree unit. excludes signaling the number of tile rows or the number of tile columns if they are less than or equal to the width of the tile 21. The method of solution 20, wherein

[0187] The following solutions represent exemplary implementations of the techniques discussed in the previous section (eg, item 16).

[0188] 22. A video processing method comprising: a video including one or more video pictures; and coding the video. This includes converting between the coded representation and the format This formatting rule complies with the rules for evenly spaced tiles and unevenly spaced tiles. This coded representation for a picture comprising: It provides that:

[0189] 23. The tile layout information is a syntax flag included in a picture parameter set. The method described in Solution 22.

[0190] 24. The number of clearly signaled rows or columns of tiles is equal to the number of unevenly spaced tiles. The method according to any one of Solutions 22 to 23, wherein

[0191] 25. The number of clearly signaled rows or columns of tiles is equal to the number of uniformly spaced tiles. 24. The method according to any one of Solutions 22 to 23, wherein the

[0192] 26. Any one of the solutions above, wherein the video domain includes a video coding unit. The method described below.

[0193] 27. A method according to any one of the preceding solutions, wherein the video region comprises a video picture.

[0194] 28. The transforming includes encoding the video into the coded representation. The method described in any of Solutions 1 to 27.

[0195] 29. The transform decodes the coded representation to generate pixel values ​​for the image. 28. The method of any of Solutions 1 to 27, comprising:

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

[0197] 31. A processor configured to implement the method described in one or more of solutions 1 to 29. A video encoding device comprising:

[0198] 32. A computer program product having computer code stored therein, The code, when executed by a processor, causes the processor to A computer program product implementing the method described above.

[0199] 33. A method, apparatus or system as described herein.

[0200] FIG. 13 is a flowchart showing a video processing method according to the present technology. 300, in operation 1310, according to the rules, the video picture and the video bitstream. This video picture includes one or more slices. This rule replies that a condition is met by tiling two rectangular slices. The present invention provides for signaling syntax elements that indicate differences between slice indices, where Let one of the boxes be denoted as i (where i is an integer).

[0201] In some embodiments, the second of the two rectangular slices is (i+1 )-th rectangular slice, and the syntax element is represented as the (i+1)-th rectangular slice. a first tile index of a first tile including a first coding tree unit in the The i-th rectangular slice contains the first coding tree unit in the second tile. In some embodiments, the difference between the at least one tile index is The step in which one condition is satisfied is when i is (the number of rectangular slices in the video picture−1). In some embodiments, the at least one condition is smaller than is satisfied when i is equal to (the number of rectangular slices in the video picture minus 1). This includes not having

[0202] FIG. 14 is a flowchart showing a video processing method according to the present technology. 400, in operation 1410, according to a rule, the video picture and the video bitstream. This video picture may be divided into one or more subpictures. Each subpicture comprises one or more rectangular slices. Derive slice indices at the subpicture level for each rectangular slice in the image. and determines the number of coding tree units in each slice.

[0203] In some embodiments, the slice index at the sub-picture level is The slice order is determined based on the decoding order of the corresponding slice in the list of slices in the slice table. In some embodiments, the first slice at the sub-picture level for the first slice The index is the second slice index at the subpicture level for the second slice. If , the first slice is processed before the second slice in decoding order. In some embodiments, the slice index at the sub-picture level is represented by the variable Sub picLevelSliceIdx. In some embodiments, the slice The slice address is determined based on the slice index at the sub-picture level. In some embodiments, the slice index at the sub-picture level of a slice The slice size is determined based on the first subpicture that contains the slice. In , the slice indexes at the subpicture level are non-negative integers. In an embodiment, the slice index at the sub-picture level is greater than or equal to 0 and less than N. , N is the number of slices in the subpicture.

[0204] In some embodiments, if the first slice and the second slice are different, the first slice The first slice index at the subpicture level for the first slice is the subpicture level for the second slice. Unlike the second slice index at the picture level, the first and second slices In some embodiments, the subpicture for the first slice is The first slice index of the picture level is the subpicture level for the second slice. If the second slice index is smaller than the picture-level index for the first slice, The first slice index is the picture-level second slice index for the second slice. In some embodiments, the sub-picture level of one slice is The slice index at the picture level is the slice index of this slice at the picture level. The decision is based on the index.

[0205] FIG. 15 is a flow chart illustrating a video processing method in accordance with the present technology. 0 is a video picture and a video including one or more sub-pictures in step 1510. For conversion between bitstreams, one slice in one subpicture The sub-picture level slice index of this slice and the picture level slice index of this slice. The method 1500 also includes determining a mapping relationship between the index and the At 1520, performing a transformation based on the determination.

[0206] In some embodiments, the mapping relationship is a picture-level mapping of the sub-pictures. 2D indexed using slice and subpicture indices In some embodiments, the picture-level slice index is represented as an array. The number of slices is determined based on an array indicating the number of slices in each of the one or more subpictures. In some embodiments, the two-dimensional array and The array showing the number of slices and the picture-level slice index is In some embodiments, the slice pitch is determined based on a sequential scanning process. A texture-level slice index is determined using the mapping relationship, and the slice The number of coding tree blocks and / or addresses in a slice is The determination is based on the picture level slice index.

[0207] FIG. 16 is a flowchart showing a video processing method according to the present technology. 600, in step 1610, according to the rules, the video picture and the video bitstream. This video picture may be divided into one or more subpictures. This rule requires that a tile of an image be entirely contained within a single sub-picture of the image picture. It specifies that the location

[0208] In some embodiments, the first slice is located in the first tile, and the first slice is located in the first The second slice is located in the second tile. The first tile is different from the second tile, and the first slice and the second slice are one. are located in different slices of the subpicture.

[0209] FIG. 17 is a flowchart showing a video processing method according to the present technology. 700, in step 1710, according to the rules, the video picture and the video bitstream. This video picture may be divided into one or more subpictures. This bitstream includes a picture segmentation mechanism that segments pictures into syntactic structures associated with the picture. It conforms to formatting rules that stipulate that the information contained therein is

[0210] In some embodiments, the syntax structure is a picture header or a picture parameter set. In some embodiments, the video unit includes information dividing the picture. In some embodiments, the syntax structure includes a flag indicating whether the The video unit may include a picture header, a picture parameter set, or a sequence parameter set. In some embodiments, the information dividing the picture is stored in the picture header. If the information contained in the picture header is included in both the picture parameter set and the picture header, The information is used for the conversion.

[0211] FIG. 18 is a flow chart illustrating a video processing method in accordance with the present technology. 0 is a block diagram of a video image having one or more slices with a non-rectangular shape, in step 1810. To convert between this video picture and the bitstream of this video, The method 1800 also includes determining slice division information for the image. and performing a conversion based on that determination.

[0212] In some embodiments, the slice division information is stored in a video unit of the video. The video unit comprises a picture parameter set or a picture header. In the embodiment, the bitstream includes slice division information of the video picture. A format that specifies that the slice is included in a syntactic structure associated with the video unit that contains the slice. In some embodiments, the slice division information for a video picture is In some embodiments, the video picture includes a value indicating the number of slices in the picture. The slice division information of the slice is an index of one block unit in one slice. In some embodiments, a value indicating a block unit in a slice. The value indicating the index of the unit is omitted from the slice division information of the video picture. In some embodiments, the slice division information of the video picture includes a block number within a slice. In some embodiments, the number of blocks in a slice is 1. The value indicating the number of units is omitted from the slice division information of the video picture. In an embodiment, the block unit is a coding tree unit or a tile. In some embodiments, slice division information for a video picture is extracted from a slice header. In some embodiments, the slice index of a slice is omitted. The picture-level slice index of the slice is contained in the slice header. It is judged based on.

[0213] In some embodiments, the slice division information for each of the one or more slices is stored in a video unit. In some embodiments, one or more sequences are organized in order of syntactic structure associated with the sequence. The slice division information for each slice is included in the syntax structure in ascending order. Thus, the slice division information for each of the one or more slices is included in the syntactic structure in descending order.

[0214] In some embodiments, the slice of at least one of the one or more slices In some embodiments, the segmentation information is omitted in the bitstream. slice partition information of at least one slice of the slices above In some embodiments, the slice partition information of the slices included in the slices is inferred. , the number of block units for slice S-1 is not included in the bitstream, where S represents the number of slices in a video picture, and S is greater than 1.

[0215] FIG. 19 is a flow chart illustrating a video processing method in accordance with the present technology. 0, in step 1910, a video picture of a video including one or more slices and a This involves converting between video picture and bitstreams according to rules. The number of slices in the image processor is determined by whether rectangular or non-rectangular division is applied to the video picture. The number of slices must be equal to or greater than the minimum number determined based on the number of slices required.

[0216] In some embodiments, when non-rectangular division is applied, the minimum number of slices is 2. , if rectangular division is applied, the minimum number of slices is 1. In some embodiments, If non-rectangular subdivision is applied, the minimum number of slices is 1, and if rectangular subdivision is applied, The minimum number of slices is 1. In some embodiments, the minimum number of slices is 1. A further determination is made based on the number of sub-pictures in the picture.

[0217] FIG. 20 is a flowchart showing a video processing method according to the present technology. 000, in step 2010, according to the rules, the image picture and the image bitstream This video picture includes one or more slices. When slice division information of a video picture is included in the syntax structure of a video unit , a slice is represented by its top left position and the dimensions of the slice.

[0218] In some embodiments, the location and dimensions of the top left corner of a slice are determined by the size of the block within the slice. The top left position of the block unit, the dimensions of the block unit, and the dimensions of the block unit In some embodiments, each slice is shown with its dimensions measured at the time of the slice. The top left position of the slice and the dimensions of each slice are included in the syntactic structure in turn.

[0219] FIG. 21 is a flowchart showing a video processing method according to the present technology. In step 2110, the image picture and the image bitstream are generated according to the rules. This video picture may be divided into one or more subpictures. Each subpicture comprises one or more slices. This specifies how partition information for one or more slices in a data stream is present in the bitstream. .

[0220] In some embodiments, the video unit comprises a sequence parameter set, a picture In some embodiments, the one of the The above sub-picture division information is arranged in ascending order based on the sub-picture index. In some embodiments, the partition information for one or more slices in each subpicture are arranged in ascending order based on the sub-picture level slice index.

[0221] FIG. 22 is a flowchart showing a video processing method according to the present technology. In step 2210, the image picture and the image bitstream are generated according to the rules. This video picture is a representation of one or more rectangular slides. Each slice comprises one or more tiles. th Rectangular Slice The first tile index of the first tile in (i+1) th In rectangular slices It is provided to omit signaling the difference between the second tile index of the first tile. Determine.

[0222] In some embodiments, (i+1) th The second tile of the first tile in a rectangular slice The file index is 0 th From i th Based on a rectangular slice indexed into In some embodiments, (i+1) th First in rectangular slice The second tile index of the tile is 0 th From i th Rectangles indexed into It can be the smallest tile index outside the range defined by the slice.

[0223] FIG. 23 is a flow chart illustrating a video processing method in accordance with the present technology. 0 performs conversion between video picture and video bitstream in step 2310. information for deriving the number of tile columns and the number of tile rows in a video picture to perform However, the bit rate is adjusted depending on the relationship between the dimensions of the video picture and the dimensions of the coding tree block. The method 2300 also includes the steps of: At 2320, performing a transformation based on the determination.

[0224] In some embodiments, the width of a video picture is less than or equal to the width of a coding tree block. In some embodiments, if the video picture height is If it is less than or equal to the height of the coding tree block, the information is omitted.

[0225] FIG. 24 is a flowchart showing a video processing method according to the present technology. 400, in step 2410, according to the rules, the video picture and the video bitstream. This video picture may be divided into one or more subpictures. This bitstream conforms to the format rules and There is a variable in the subpicture_id that specifies the subpicture identifier of the subpicture that contains one slice. If the second variable corresponding to this syntax element is equal to this variable, It specifies that there is only one

[0226] In some embodiments, the variable is slice_subpic_id and the second variable is SubpicIdVal. The syntax element corresponding to this syntax element is SubpicI It is represented by dVal[CurrSubpicIdx].

[0227] FIG. 25 is a flowchart showing a video processing method according to the present technology. 500, in step 2510, according to the rules, the video picture and the video bitstream. This video picture may be divided into one or more subpictures. If non-rectangular division is applied in the bitstream or sub-picture information is not available, If the information is omitted, two tiles in one slice will have different addresses.

[0228] In some embodiments, the first syntax flag, rect_slice_flag, is non- A second syntax flag, subpic_info_pres, indicates whether rectangle division is applied. ent_info indicates whether the subpicture information is present in the bitstream.

[0229] FIG. 26 is a flowchart showing a video processing method according to the present technology. 600, in step 2610, according to the rules, the video picture and the video bitstream. This video picture comprises one or more tiles. This rule applies when one or more tiles are organized with both uniform and non-uniform spacing. In this case, we specify that one syntax element is used to indicate the type of tile layout.

[0230] In some embodiments, syntax elements are not uniformly spaced in the tile layout. A picture parameter indicating whether uniform intervals or non-uniform intervals are followed by uniform intervals. In some embodiments, the tile layout is comprised of non-uniformly spaced tiles. The number of columns or rows of tiles that contain and are clearly indicated shall not be less than or equal to the total number of unevenly spaced tiles. In some embodiments, the tile layout includes uniformly spaced tiles. , the number of columns or rows of tiles that are clearly shown is equal to or greater than the total number of uniformly spaced tiles. In some embodiments, the tile layout includes uniform spacing followed by non-uniform spacing, The dimensions of the unevenly spaced tiles are determined first based on the first reverse order, and then based on the second reverse order. The dimensions of the evenly spaced tiles are determined. In some embodiments, the dimensions are This includes the width of a column of tiles or the height of a row of tiles.

[0231] FIG. 27 is a flowchart showing a video processing method according to the present technology. 700, in step 2710, according to the rules, the video picture and the video bitstream. This rule involves converting between the merged estimate region ( Whether to handle the size of the Merge Estimation Region (MER) or how to process it depends on the minimum allowable coding block size. This stipulates:

[0232] In some embodiments, the MER size is the minimum allowable coding block size In some embodiments, the MER size can be MER_size The minimum allowable coding block size is denoted by MinCbSizeY, and Lo The difference between g2(MER_size) and Log2(MinCbSizeY) is the bitstream It is included in the program.

[0233] FIG. 28 is a flow chart illustrating a video processing method in accordance with the present technology. 0, in step 2810, according to the rule, an image having at least one image tile is generated. This rule involves converting between the coding tree and this video bitstream. The height of a slice in a video tile in units of slice units is expressed as the video tile containing that slice. The number of slice heights explicitly provided for the slices in the file. It specifies that the derivation is based on the value of the first syntax element.

[0234] In some embodiments, in a video tile on a coding tree unit basis, The slice height is derived from the image information if the value of the first syntax element is equal to 0. In some embodiments, the coding tree unit is used to scale the video tiles. The height of the chair is represented by sliceHeightInCtus[i]. ightInCtus[i] is the row height RowHeight[SliceTopLef tTileIdx[i] / NumTileColumns, where Sl iceTopLeftTileIdx is the first coding tree unit in the slice. specifies the tile index of the tile that contains the tile, and NumTileColumns specifies the number of tile columns that contain the tile. The value of RowHeight[j] specifies the number of file columns in the coding tree block. Specifies the height of the jth row in units of blocks.

[0235] In some embodiments, in a video tile on a coding tree unit basis, The slice height is the height of the slice in the video tile that does not exist in the bitstream. In some embodiments, the coding tree units are derived from the video information. The height of the slice in the video tile in units of frames is The second syntax element is derived based on the second syntax element present in the bitstream. In this state, if the first syntax element is equal to 0, the video tile containing this slice is divided into multiple slices. Not divided into rice.

[0236] FIG. 29 is a flow chart illustrating a video processing method in accordance with the present technology. 29. In step 2910, a video picture is generated that includes video tiles that include one or more slices. and converting the video into a bitstream according to a rule. This rule applies if the second slice in the tile containing the first slice in the picture is The first slice is defined as a slice with a height expressed in reading tree units. , the first slice index, and the second slice index and the image The second slice is determined based on the number of slice heights explicitly provided in the image tile. Based on the first slice index and the second slice index, The height of the second slice is determined by the above equation.

[0237] In some embodiments, the first slice index is i, and the second slice index is Let the exponent be (num_exp_slices_in_tile[i]-1), where: num_exp_slices_in_tile is provided explicitly in the image tile. The height of the second slice is specified by exp_slice_height. ght_in_ctus_minus1[i][num_exp_slices_in_ tile[i]-1]+1, where exp_slice_heig ht_in_ctus_minus1 is the coding tree unit in the video tile In some embodiments, the slice height is specified in units of pixels. The uniform slice height is exp_slice_height_in_ctus_min In some embodiments, the second slice is always In some embodiments, the height of the second slice is It is not allowed to be reset. In some embodiments, (num_exp_s The third slice with an index greater than lices_in_tile[i]-1) The height of exp_slice_height_in_ctus_minus1[i][ num_exp_slices_in_tile[i]-1]. In some embodiments, the second slice is not present in the image tile. In this case, the height of the second slice is exp_slice_height_in_ctus_m. inus1[i][num_exp_slices_in_tile[i]-1+1 or less is.

[0238] FIG. 30 is a flow chart illustrating a video processing method according to the present technology. In step 3010, the method includes: generating an image comprising an image picture including one or more tiles; This includes converting between a video bitstream and a video picture. This picture parameter set points to the conforms to formatting rules that specify that a tile contains a list of column widths for N tile columns, Here, N is an integer. There is an (N-1)-th tile column in the video picture, and (N -1) The width of the tile column is the width of the tile column that is clearly included in the tile column. Equals the (N-1)th entry in the list to which the block was added.

[0239] In some embodiments, N-1 is num_exp_tile_columns_m In some embodiments, the unit of the coding tree block is represented as inus1. The width of a tile column in is tile_column_width_minus1[num _exp_tile_columns_minus1]+1, and til e_column_width_minus1 is in units of coding tree blocks. In some embodiments, the coding tree block The tile column width in units of is not allowed to be reset, and tile_col umn_width_minus1[num_exp_tile_columns_mi In some embodiments, the coding tree is determined based only on The width of the tile column in blocks is tile_column_width_min Equal to us1[num_exp_tile_columns_minus1]+1. In some implementations, num_exp_tile_columns_minus1 The width of the second tile column with a larger index is tile_column_widt Based on h_minus1[num_exp_tile_columns_minus1] It is judged based on this.

[0240] FIG. 31 is a flow chart illustrating a video processing method in accordance with the present technology. In step 3110, the method includes: generating an image comprising an image picture including one or more tiles; This includes converting between a video bitstream and a video picture. This picture parameter set points to the conforms to formatting rules that stipulate that a tile contains a list of row heights for N tile rows. , where N is an integer. There is an (N-1)th tile row in the video picture, The height of the (N-1)th tile row in the The (N-1)th entry in the list plus the rasterizing tree block.

[0241] In some embodiments, N-1 is num_exp_tile_rows_minu In some embodiments, the time in units of coding tree blocks is The height of a tile row is tile_row_height_minus1[num_exp_ti tile_row_he ight_minus1 specifies the height of the tile row in units of coding tree blocks In some embodiments, the tile rows in units of coding tree blocks The height of the tile is not allowed to be reset and the tile_row_height_mi Determined based only on nus1[num_exp_tile_row_minus1] In some embodiments, the height of a tile row in units of coding tree blocks tile_row_height_minus1[num_exp_tile_r ow_minus1]+1. In some embodiments, num_exp_ti The height of the second tile row with an index greater than le_rows_minus1 is tile_row_height_minus1[num_exp_tile_rows _minus1] is used as the basis.

[0242] In some embodiments, the conversion comprises encoding the video into the bitstream. In some embodiments, the converting includes converting the video to the bitstream. This includes decoding from the system.

[0243] In the solution described herein, the encoder encodes the data according to the format rules. By generating a bounded representation, the formatting rules can be adhered to. In the solution described in According to the above, the syntactic elements in the coded representation are analyzed and decoded with knowledge of the presence or absence of the syntactic elements. The image may be generated.

[0244] As used herein, the term "video processing" refers to video encoding, video decoding, video compression, or For example, a video compression algorithm may convert a pixel representation of a video into a corresponding It may be applied during conversion to a bitstream representation or vice versa. The bitstream representation of a block may be, for example, a bitstream representation of a block, as specified by the syntax. These may correspond to bits that are spread at the same or different locations in the stream. For example, a macroblock is a block of data in terms of transformed and coded error residual values, and using bits in the header and other fields in the bitstream Furthermore, during the conversion, the decoder may with the knowledge that some fields may or may not be present based on the configuration. Similarly, an encoder may parse the bitstream using a particular syntax field. Determines whether the syntax field should be included or not. to be included in or excluded from coded representations may generate a coded representation accordingly.

[0245] The disclosed and other solutions, examples, embodiments, modules, The implementation of the rules and functional operations is within the scope of the structures disclosed herein and their structural equivalents. any digital electronic circuit, including computer software, firmware, or may be implemented in hardware, or in a combination of one or more thereof. The disclosed and other embodiments may include one or more computer programs. a product, i.e., a data processing apparatus to be implemented by, or the operation of, a data processing apparatus computer program instructions encoded on a computer-readable medium for controlling The computer-readable medium may be implemented as one or more modules of , machine-readable storage devices, machine-readable storage substrates, memory devices, machine-readable propagating signals The data may be a composition of matter, or a combination of one or more of these. The term "processing device" refers to, for example, a programmable processor, a computer, or a any device for processing data, including a number of processors or computers, This includes hardware, devices, and machines. The code that creates the execution environment for the program, e.g., processor firmware, protocol stack network, database management system, operating system, or one or more of these A propagated signal may contain a code consisting of a combination of numbers. A signal, for example, a machine-generated electrical, optical, or electromagnetic signal, transmitted to a suitable receiving device. It is generated to encode information for

[0246] Computer programs (programs, software, software applications) , script, or code) is a language that is written in a compiled or interpreted It can be written in any form of programming language, including standard Modules suitable for use as standalone programs or in any computing environment Developed in any form, including as a module, component, subroutine, or other unit. A computer program does not necessarily have to be a file in a file system. It does not necessarily correspond to a file. A program may contain other programs or data. Part of a file (e.g., one or more scripts stored in a markup language document) ) or in a single file dedicated to that program. or multiple coordination files (e.g., one or more modules, subprograms, or The computer program may be stored in a file (or a file containing part of the code). The system can be managed by a single computer located at one site or distributed across multiple sites. Deploy it to run on multiple computers interconnected by a network It is also possible.

[0247] The processes and logic flows described herein operate on input data and produce output. execute one or more computer programs to perform functions by creating This can be done by one or more programmable processors. Low also refers to application-specific logic circuits, such as FPGAs (Field Programmable Gate Arrays). This can be done by a chip array (CSI) or an ASIC (application specific integrated circuit), It can also be implemented as special purpose logic circuitry.

[0248] Processors suitable for executing computer programs include, for example, general purpose and special purpose microprocessors. both the processor and any one or more Typically, a processor is a programmable logic device that accesses read-only memory or random access memory. It receives instructions and data from internal memory or both. The element comprises a processor for executing instructions and one or more memory devices for storing instructions and data. Generally, a computer uses one or more memory devices to store data. or multiple mass storage devices, e.g., magnetic, magneto-optical, or optical disks may include or receive data from these mass storage devices However, the computer may be operatively coupled to transfer data to the It is not necessary for a computer to have such a device. Suitable computer readable media for storing the present invention include any type of non-volatile memory, media, and memory devices, such as EPROM, EEPROM, flash storage , magnetic disks, such as internal hard disks or removable disks, magneto-optical disks This includes semiconductor storage devices such as DVD-ROM and CD-ROM disks. The processor and memory may be supplemented by special purpose logic circuitry, or may be It may be incorporated into the logic circuitry of the application.

[0249] This patent specification contains many details, which may not be sufficient to encompass the scope of any subject matter or the scope of any claim. The present invention should not be construed as limiting the scope of the present invention, but rather as being specific to particular embodiments of particular technologies. The description of the features that may be present in the present patent document should be interpreted as a description of the features that may be present in the present patent document. Certain features described in the context may be implemented in combination in a single example. Conversely, various features that are described in the context of one example may be used in multiple embodiments. Further, the features may be implemented separately or in any suitable subcombination. The compounds described above as acting in specific combinations and originally claimed as such However, one or more features from a claimed combination may, in some cases, be combined. The claimed combination may be extracted from the combination, and the claimed combination may be a subcombination or may be directed to subcombination variations.

[0250] Similarly, although operations may be shown in a particular order in the figures, this is not to be construed as a guarantee that a desired result will be achieved. that such actions be performed in the particular order or sequence shown, in order to It should not be understood as requiring that all actions be performed. Also, the separation of the various system components in the examples described in this patent specification It should not be understood that all embodiments require such separation.

[0251] Only some implementations and examples are described and illustrated in this patent document. Other embodiments, extensions, and variations are possible based on the content provided.

Claims

1. A video data processing method, comprising: determining that a first scanning process is applied to a video picture to divide the video picture into one or more tiles, one or more slices, and a plurality of coding tree units for a first conversion between a video including the video picture referencing a picture parameter set and a bitstream of the video; determining that the picture parameter set includes a list of syntax elements each indicating a tile column width of N tile columns having N indices, N being an integer; performing the first transformation based on the determination; the list of syntax elements includes a first syntax element plus 1 that directly specifies an N-th tile column width of the N tile columns in coding tree block units without reference to other information; the value of the first syntax element is used to derive a tile column width having an index greater than the N indices; determining that a third scanning process is applied to the video pictures for a third conversion between the video and the bitstream of the video, the third scanning process including the video pictures referencing a picture parameter set (PPS), and the video pictures are divided into one or more tiles, one or more slices, and a plurality of coding tree units; determining, in the third scanning process, that a ninth syntax element is conditionally included in a PPS in the bitstream to indicate a number of rectangular slices of the video picture; determining, for a number of rectangular slices having a first slice index, that a tenth syntax element is conditionally included in the bitstream to indicate a number of slice heights explicitly provided for slices in a video tile that includes the rectangular slice having the first slice index, wherein the number of slice heights explicitly provided for slices in the video tile is equal to T, where T is greater than or equal to 0; determining that T eleventh syntax elements are included in the bitstream to indicate slice heights of T slices in units of coding tree units (CTUs), where T is equal to or greater than 1; performing the third transformation based on the tenth syntax element and T eleventh syntax elements; If the height of the image tile is greater than the sum of the slice heights of the T slices, slice heights of the remaining slices in the image tile other than the T slices are determined based on the slice height of the last slice of the T slices; If the value of the tenth syntax element is equal to 0, the eleventh syntax element is omitted from the bitstream, and the height of a slice within the video tile is derived to be equal to the height of the video tile in coding tree block units; If the ninth syntax element is equal to 0, the third scanning process is applied to the video picture; or if a syntax element specifying a width of the rectangular slice having the first slice index in tile columns plus 1 is equal to 0 and a thirteenth syntax element specifying a height of the rectangular slice having the first slice index in tile rows plus 1 is equal to 0, the third scanning process is applied to the video picture. Video data processing method.

2. The method of claim 1 , wherein the value of N is indicated by a second syntax element included in the picture parameter set.

3. The method of claim 1 , wherein a width of an Nth tile column of N tile columns in a coding tree block unit is prohibited from being reset.

4. 2. The method of claim 1 , wherein the first syntax element is an Nth entry in the list of syntax elements, a uniform tile column width is set to the Nth tile column width of the N tile columns, and if a difference between a picture width of a luminance component in coding tree block units and a sum of the tile column widths of the N tile columns is equal to or greater than the Nth tile column width of the N tile columns, then an (N+1)th tile column width is set to be equal to the Nth tile column width of the N tile columns.

5. 2. The method of claim 1, wherein if a difference between a picture width of a luminance component in units of a coding tree block and a sum of the tile column widths of the N tile columns is smaller than the width of an Nth tile column of the N tile columns, the width of an (N+1)th tile column is set to be equal to the difference.

6. the picture parameter set further includes a list of syntax elements indicating tile row heights of M tile rows having M indices, respectively, where M is an integer; the list of syntax elements includes a third syntax element plus one that directly specifies an M-th tile row height of M tile rows in coding tree block units without reference to other information; The method of claim 1 , wherein the value of a third syntax element is used to derive tile row heights having indices greater than the M indices.

7. The value of M is indicated by a fourth syntax element included in the picture parameter set, The height of the M-th tile row among the M tile rows in the coding tree block unit is prohibited from being reset, the third syntax element is an M-th entry in the list of syntax elements, and a uniform tile row height is set to the M-th tile row height of the M-th tile rows; and if a difference between the picture height of the luma component in units of coding tree blocks and the sum of the tile row heights of the M-th tile rows is equal to or greater than the M-th tile row height of the M-th tile rows, the (M+1)-th tile row height is set equal to the M-th tile row height of the M-th tile rows; or 7. The method of claim 6, wherein if a difference between a picture height of a luma component in coding tree block units and a sum of tile row heights of M tile rows is equal to or greater than an M-th tile row height of M tile rows, the (M+1)-th tile row height is set equal to the difference.

8. applying a second scanning process to the video picture for a second conversion between the video including the video picture and the bitstream of the video to determine that the video picture is divided into one or more tiles, one or more slices, and a plurality of coding tree units; In the second scanning process, determining whether a height of the first slice in a video tile including the first slice in units of coding tree units (CTUs) is derived or included in the bitstream based on a value of a fifth syntax element corresponding to the first slice; performing the second transformation based on the determination; the fifth syntax element is included in a picture parameter set in the bitstream in response to a set of conditions being satisfied; The set of conditions includes the first slice being in a rectangular mode, a value of a sixth syntax element specifying a difference between a width of the first slice in tile columns and 1 being equal to 0, a value of a seventh syntax element specifying a difference between a height of the first slice in tile rows and 1 being equal to 0, 2. The method of claim 1, wherein in response to the value of the fifth syntax element being a first value, a height of the first slice in the tile containing the first slice in coding tree units is derived for the video.

9. If the fifth syntax element is not present in the bitstream, the fifth syntax element is inferred to have the first value; or If the value of the fifth syntax element is the first value, the height of the first slice in the video tile including the first slice in coding tree unit units is equal to RowHeight[TileIdx / NumTileColumns]; RowHeight[j] specifies the j-th tile row height in coding tree block units; TileIdx specifies the tile index of the tile containing the first CTU in the first slice. The method of claim 8 , wherein NumTileColumns specifies the number of tile columns.

10. 9. The method of claim 8, wherein if the fifth syntax element has a value of W, and W is different from the first value, W eighth syntax elements specifying slice height values ​​within the video tile containing the first slice in CTU row units are each included in a picture parameter set in the bitstream.

11. The slice height of the T slices in CTU row units is equal to the value of the eleventh syntax element of the T eleventh syntax elements corresponding to the slice plus 1, or 2. The method of claim 1, wherein, if a difference between the height of the video tile in coding tree block units and the sum of the slice heights of the T slices is equal to or greater than the slice height of the last slice of the T slices, the slice height of one remaining slice of the video tile other than the T slices is set to be equal to the slice height of the last slice of the T slices.

12. The uniform slice height is equal to the slice height of the last slice of the T slices, 2. The method of claim 1, wherein if the remainder of the image tile other than the T slices and one or more of the uniform slices have slice heights that are less than the uniform slice height, the slice height of the last slice of the image tile is set to be the difference between the height of the image tile and the sum of the slice heights of the T slices and the one or more of the uniform slices.

13. If a difference between the height of the image tile in coding tree block units and the sum of the slice heights of the T slices is less than a uniform slice height, the slice height of the (T+1)th slice of the image tile is set to be the difference; or 2. The method of claim 1, further comprising: inhibiting a slice height of a last slice of the T slices from being reset; and using a value of a last 11th syntax element of the T 11th syntax elements directly to derive a uniform slice height without reference to other information.

14. The method of any one of claims 1 to 13, wherein the converting comprises encoding the video into the bitstream.

15. The method of any one of claims 1 to 13, wherein the conversion comprises decoding from the bitstream to the video.

16. 1. A video data processing apparatus including a processor and a non-transitory memory having instructions that, when executed by the processor, cause the processor to: determining that a first scanning process is applied to a video picture to divide the video picture into one or more tiles, one or more slices, and a plurality of coding tree units for a first conversion between a video including the video picture referencing a picture parameter set and a bitstream of the video; determining that the picture parameter set includes a list of syntax elements each indicating a tile column width of N tile columns having N indices, N being an integer; performing the first transformation based on the determination; the list of syntax elements includes a first syntax element plus 1 that directly specifies an N-th tile column width of the N tile columns in coding tree block units without reference to other information; the value of the first syntax element is used to derive a tile column width having an index greater than the N indices; determining that a third scanning process is applied to the video pictures for a third conversion between the video and the bitstream of the video, the third scanning process including the video pictures referencing a picture parameter set (PPS), and the video pictures are divided into one or more tiles, one or more slices, and a plurality of coding tree units; determining, in the third scanning process, that a ninth syntax element is conditionally included in a PPS in the bitstream to indicate a number of rectangular slices of the video picture; determining, for a number of rectangular slices having a first slice index, that a tenth syntax element is conditionally included in the bitstream to indicate a number of slice heights explicitly provided for slices in a video tile that includes the rectangular slice having the first slice index, wherein the number of slice heights explicitly provided for slices in the video tile is equal to T, where T is greater than or equal to 0; determining that T eleventh syntax elements are included in the bitstream to indicate slice heights of T slices in units of coding tree units (CTUs), where T is equal to or greater than 1; performing the third transformation based on the tenth syntax element and T eleventh syntax elements; If the height of the image tile is greater than the sum of the slice heights of the T slices, slice heights of the remaining slices in the image tile other than the T slices are determined based on the slice height of the last slice of the T slices; If the value of the tenth syntax element is equal to 0, the eleventh syntax element is omitted from the bitstream, and the height of a slice within the video tile is derived to be equal to the height of the video tile in coding tree block units; If the ninth syntax element is equal to 0, the third scanning process is applied to the video picture; or if a syntax element specifying a width of the rectangular slice having the first slice index in tile columns plus 1 is equal to 0 and a thirteenth syntax element specifying a height of the rectangular slice having the first slice index in tile rows plus 1 is equal to 0, the third scanning process is applied to the video picture. Video data processing device.

17. A non-transitory computer-readable storage medium storing instructions, the instructions causing a processor to: determining that a first scanning process is applied to a video picture to divide the video picture into one or more tiles, one or more slices, and a plurality of coding tree units for a first conversion between a video including the video picture referencing a picture parameter set and a bitstream of the video; determining that the picture parameter set includes a list of syntax elements each indicating a tile column width of N tile columns having N indices, N being an integer; performing the first transformation based on the determination; the list of syntax elements includes a first syntax element plus 1 that directly specifies an N-th tile column width of the N tile columns in coding tree block units without reference to other information; the value of the first syntax element is used to derive a tile column width having an index greater than the N indices; determining that a third scanning process is applied to the video pictures for a third conversion between the video and the bitstream of the video, the third scanning process including the video pictures referencing a picture parameter set (PPS), and the video pictures are divided into one or more tiles, one or more slices, and a plurality of coding tree units; determining, in the third scanning process, that a ninth syntax element is conditionally included in a PPS in the bitstream to indicate a number of rectangular slices of the video picture; determining, for a number of rectangular slices having a first slice index, that a tenth syntax element is conditionally included in the bitstream to indicate a number of slice heights explicitly provided for slices in a video tile that includes the rectangular slice having the first slice index, wherein the number of slice heights explicitly provided for slices in the video tile is equal to T, where T is greater than or equal to 0; determining that T eleventh syntax elements are included in the bitstream to indicate slice heights of T slices in units of coding tree units (CTUs), where T is equal to or greater than 1; performing the third transformation based on the tenth syntax element and T eleventh syntax elements; If the height of the image tile is greater than the sum of the slice heights of the T slices, slice heights of the remaining slices in the image tile other than the T slices are determined based on the slice height of the last slice of the T slices; If the value of the tenth syntax element is equal to 0, the eleventh syntax element is omitted from the bitstream, and the height of a slice within the video tile is derived to be equal to the height of the video tile in coding tree block units; If the ninth syntax element is equal to 0, the third scanning process is applied to the video picture; or the third scanning process is applied to the video picture when a syntax element specifying a width of the rectangular slice having the first slice index in tile columns plus 1 is equal to 0 and a thirteenth syntax element specifying a height of the rectangular slice having the first slice index in tile rows plus 1 is equal to 0. A non-transitory computer-readable storage medium.

18. 1. A method for storing a video bitstream, comprising: determining that a first scanning process is applied to a video picture to divide the video picture into one or more tiles, one or more slices, and a plurality of coding tree units for a first conversion between a video including the video picture referencing a picture parameter set and a bitstream of the video; determining that the picture parameter set includes a list of syntax elements each indicating a tile column width of N tile columns having N indices, N being an integer; generating the bitstream based on the determination; the list of syntax elements includes a first syntax element plus 1 that directly specifies an N-th tile column width of the N tile columns in coding tree block units without reference to other information; the value of the first syntax element is used to derive a tile column width having an index greater than the N indices; determining that a third scanning process is applied to the video pictures for a third conversion between the video and the bitstream of the video, the third scanning process including the video pictures referencing a picture parameter set (PPS), and the video pictures are divided into one or more tiles, one or more slices, and a plurality of coding tree units; determining, in the third scanning process, that a ninth syntax element is conditionally included in a PPS in the bitstream to indicate a number of rectangular slices of the video picture; determining, for a number of rectangular slices having a first slice index, that a tenth syntax element is conditionally included in the bitstream to indicate a number of slice heights explicitly provided for slices in a video tile that includes the rectangular slice having the first slice index, wherein the number of slice heights explicitly provided for slices in the video tile is equal to T, where T is greater than or equal to 0; determining that T eleventh syntax elements are included in the bitstream to indicate slice heights of T slices in units of coding tree units (CTUs), where T is equal to or greater than 1; generating the bitstream based on the tenth syntax element and T eleventh syntax elements; storing the bitstream on a non-transitory computer-readable recording medium; If the height of the image tile is greater than the sum of the slice heights of the T slices, slice heights of the remaining slices in the image tile other than the T slices are determined based on the slice height of the last slice of the T slices; If the value of the tenth syntax element is equal to 0, the eleventh syntax element is omitted from the bitstream, and the height of a slice within the video tile is derived to be equal to the height of the video tile in coding tree block units; If the ninth syntax element is equal to 0, the third scanning process is applied to the video picture; or the third scanning process is applied to the video picture when a syntax element specifying a width of the rectangular slice having the first slice index in tile columns plus 1 is equal to 0 and a thirteenth syntax element specifying a height of the rectangular slice having the first slice index in tile rows plus 1 is equal to 0. A method for storing video bitstreams.

Images