Conditionally dependent video block segmentation

Abstract

Devices, systems, and methods for video processing are described. In one representative aspect, a method for video processing is disclosed, comprising: determining, for a current video block, in response to at least one condition, whether a first partitioning mode is applicable to the current video block, wherein, under the first partitioning mode, the current video block is divided into M sub-blocks, and M>4; and performing a conversion of the current video block based on the determination.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application is an application entering the Chinese national phase based on International Patent Application No. PCT / CN2020 / 074746 filed on February 11, 2020. The entire disclosure of this application is incorporated by reference as part of the disclosure of this application. Technical Field

[0003] This patent document relates to video coding and decoding technology, equipment and system Background Art

[0004] Despite advances in video compression, digital video still accounts for the largest use of bandwidth on the Internet and other digital communications networks. As the number of connected user devices capable of receiving and displaying video increases, bandwidth demands for digital video usage are expected to continue to grow. Summary of the Invention

[0005] Devices, systems, and methods related to digital video coding and decoding, and more particularly, devices, systems, and methods related to quintree partitioning in video coding and decoding, are described. The described methods can be applied to existing video coding standards (e.g., High Efficiency Video Coding (HEVC)) and future video coding standards (e.g., Versatile Video Coding (VVC)) or codecs.

[0006] In one representative aspect, a method for video processing is disclosed, comprising: determining, for a current video block, in response to at least one condition, whether a first partitioning mode is applicable to the current video block, wherein, under the first partitioning mode, the current video block is divided into M sub-blocks, and M>4; and performing a conversion of the current video block based on the determination.

[0007] In another representative aspect, a method for video processing is disclosed, comprising: determining, for a video block, based on an indication, whether and / or how to apply a first partitioning mode to the video block, wherein the video block is divided into M parts under the first partitioning mode, M>4; and performing a conversion of the video block based on the determination.

[0008] In another representative aspect, the above method is implemented in the form of processor-executable code and stored in a computer-readable program medium.

[0009] In yet another representative aspect, a device configured or operable to perform the above method is disclosed. The device may include a processor programmed to implement the method.

[0010] In yet another representative aspect, a video decoder device may implement a method as described herein.

[0011] The above and other aspects and features of the disclosed technology are described in more detail in the drawings, the description, and the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Figure 1 An example of macroblock (MB) partitioning in H.264 / AVC is shown.

[0013] Figure 2 An example of dividing a coding block (Coding Block, CB) into prediction blocks (Prediction Block, PB) is shown.

[0014] Figure 3A and Figure 3B Examples of partitioning a Coding Tree Block (CTB) and its corresponding quadtree are shown respectively.

[0015] Figure 4 An example of a QuadTree plus Binary Tree (QTBT) is shown.

[0016] Figures 5A-5F An example of allowed partitioning in VVC is shown.

[0017] Figures 6A-6E Examples of allowed splits between a parent partition (solid line) and a current partition (dashed line) are shown, where an "X" indicates a disallowed split.

[0018] Figure 7A and Figure 7B Examples of extended quad-tree (EQT) horizontal and vertical modes are shown, respectively.

[0019] Figure 8 An example of the signaling structure of QTBT plus EQT segmentation is shown.

[0020] Figures 9A-9H An example of an unsymmetrical quad-tree (UQT) partition is shown.

[0021] Figures 10A-10E An example of a quinary tree (QUI-T) partition is shown.

[0022] Figure 11A and Figure 11B An example of a six-fold split structure is shown.

[0023] Figure 12 is a block diagram illustrating an example of a device that may implement a video encoder and / or decoder, which may be used to implement various portions of the disclosed technology.

[0024] Figure 13 A flow chart illustrating an example method for video processing according to the disclosed technology is shown.

[0025] Figure 14 A flowchart illustrating another example method for video processing according to the disclosed technology is shown. DETAILED DESCRIPTION

[0026] Due to the growing demand for higher resolution video, video coding and decoding methods and techniques are ubiquitous in modern technology. Video codecs typically include electronic circuits or software that compress or decompress digital video and are constantly being improved to provide higher coding and decoding efficiency. Video codecs convert uncompressed video to a compressed format and vice versa. There is a complex relationship between video quality, the amount of data used to represent the video (determined by the bit rate), the complexity of the encoding and decoding algorithms, sensitivity to data loss and errors, ease of editing, random access, and end-to-end delay (latency). The compression format typically conforms to a standard video compression specification, such as the High Efficiency Video Codec (HEVC) standard (also known as H.265 or MPEG-H Part 2), the soon-to-be-completed Versatile Video Codec (VVC) standard, or other current and / or future video codec standards.

[0027] Embodiments of the disclosed technology can be applied to existing video codec standards (e.g., HEVC, H.265) and future standards to improve runtime performance. Section headings are used in this document to improve the readability of the description and do not in any way limit the discussion or embodiments (and / or implementations) to only the corresponding section.

[0028] 1. Overview of Video Codec Standards

[0029] Video codec standards have evolved primarily through the development of the well-known ITU-T and ISO / IEC standards. ITU-T produced H.261 and H.263, ISO / IEC produced MPEG-1 and MPEG-4 Vision, and the two organizations worked together to produce the H.262 / MPEG-2 Video, H.264 / MPEG-4 Advanced Video Codec (AVC), and H.265 / HEVC standards. Since H.262, video codec standards have been based on a hybrid video codec structure that uses temporal prediction plus transform coding. To explore future video codec technologies beyond HEVC, VCEG and MPEG jointly established the Joint Video Exploration Team (JVET) in 2015. Since then, JVET has adopted many new methods and put them into reference software called the Joint Exploration Model (JEM). In April 2018, the Joint Video Experts Team (JVET) between VCEG (Q6 / 16) and ISO / IEC JTC1 SC29 / WG11 (MPEG) was established to work on the Versatile Video Codec (VVC) standard, with the goal of a 50% bitrate reduction compared to HEVC.

[0030] 2. Example of Quintree Partitioning

[0031] 2.1 Segmentation Tree Structure in H.264 / AVC

[0032] The terms used in H.264 / AVS are macroblock and MB mode / 8×8 mode (partitioning). A macroblock is a unit into which each picture / slice is divided and into which intra / inter mode decisions are applied. And the partitioning defines the level at which motion information is signaled.

[0033] The core of the H.264 / AVC codec layer is the macroblock, which contains a 16×16 block of luma samples and, in the typical case of 4:2:0 color sampling, two corresponding 8×8 blocks of chroma samples.

[0034] 2.1.1H.264 / AVC Main Profile

[0035] The intra codec block uses spatial prediction to exploit the spatial correlation among pixels. Two partitions are defined: 16×16 and 4×4.

[0036] Inter-frame coding blocks use temporal prediction instead of spatial prediction by estimating the motion within the picture. Motion can be estimated independently for a 16×16 macroblock or any of its sub-macroblock partitions (16×8, 8×16, 8×8). A syntax element (MB-mode) is signaled to indicate whether 16×16, 16×8, 8×16, or 8×8 is selected. If 8×8 is selected, another syntax element (8×8-mode) is further signaled to indicate whether 8×8, 8×4, 4×8, 4×4 (see, for example, Figure 1 ). Only one motion vector (MV) is allowed per partition.

[0037] 2.1.2H.264 / AVC High Profile

[0038] In the high-level, 8×8 transform and I_8×8 (8×8 intra prediction) are introduced. For intra-coded macroblocks, the transform size is fixed, I_16×6 and I_4×4 use 4×4 transform; I_8×8 uses 8×8 transform.

[0039] For macroblocks using inter-frame coding, a 4×4 or 8×8 transform can be selected. However, the transform size cannot exceed the partition size. For example, if a macroblock selects 8×8 partition and further selects 8×4 submode, only a 4×4 transform can be applied. If a macroblock selects 16×16, 16×8, 8×16, or 8×8 partition with 8×8 submode, a 4×4 or 8×8 transform can be selected.

[0040] 2.1.3 Summary

[0041] Mode selection is done at the macroblock level. The transform size must not be larger than the partition size.

[0042] 2.2 Segmentation Tree Structure in HEVC

[0043] In HEVC, the Coding Tree Unit (CTU) (also known as the largest codec unit, LCU) is divided into codec units (CU) by using a quadtree structure represented as a codec tree to adapt to various local characteristics. The decision whether to use inter-picture (temporal domain) or intra-picture (spatial domain) prediction to encode and decode a picture area is made at the CU level. Each CU can be further divided into one, two or four PUs according to the prediction unit (PU) partition type. Within a PU, the same prediction process is applied, and relevant information is sent to the decoder based on the PU. After obtaining the residual block by applying the prediction process based on the PU partition type, the CU can be partitioned into transform units (TU) according to another quadtree structure similar to the codec tree of the CU. One of the key features of the HEVC structure is that it has multiple partitioning concepts, including CU, PU and TU.

[0044] In the following, various features involved in hybrid video coding using HEVC are described as follows.

[0045] 1) Codec Tree Unit (CTU) and Codec Tree Block (CTB) Structure: A similar structure in HEVC is the Codec Tree Unit (CTU), which has a size chosen by the encoder and can be larger than a traditional macroblock. A CTU consists of a luma CTB and corresponding chroma CTBs, along with syntax elements. The luma CTB size L×L can be selected to be L=16, 32, or 64 samples, with larger sizes generally achieving better compression. HEVC supports splitting the CTB into smaller blocks using a tree structure and quadtree-like signaling.

[0046] 2) Codec Unit (CU) and Codec Block (CB): The quadtree syntax of a CTU specifies the size and position of its luma CB and chroma CB. The root of the quadtree is associated with the CTU. Therefore, the size of the luma CTB is the maximum supported size of the luma CB. The partitioning of the CTU into luma CB and chroma CB is jointly signaled. One luma CB and typically two chroma CBs together with the associated syntax form a codec unit (CU). A CTB can contain only one CU or can be partitioned to form multiple CUs, and each CU has an associated partition into prediction units (PUs) and a tree of transform units (TUs).

[0047] 3) Prediction Unit and Prediction Block (PB): The decision of whether to use inter or intra prediction to encode or decode a picture region is made at the CU level. The PU partitioning structure is rooted at the CU level. Based on the basic prediction type decision, the luma CB and chroma CB can then be further divided in size and predicted based on luma and chroma prediction blocks (PB). HEVC supports variable PB sizes from 64×64 to 4×4 samples. Figure 2 The allowed PBs are depicted.

[0048] 4) Transform Unit (TU) and Transform Block: The prediction residual is encoded and decoded using a block transform. The root of the TU tree structure is at the CU level. The luma CB residual can be the same as the luma transform block (TB), or can be further divided into smaller luma TBs. The same applies to chroma TBs. Integer basis functions similar to the discrete cosine transform (DCT) functions are defined for square TB sizes 4×4, 8×8, 16×16, and 32×32. For the 4×4 transform of the luma intra picture prediction residual, an integer transform derived from the form of the discrete sine transform (DST) is specified alternately.

[0049] 2.2.1 Depth of Quadtree

[0050] For a given luma CB of size M×M, a flag signals whether it is split into four blocks of size M / 2×M / 2. If further splitting is possible, as signaled by the maximum depth of the residual quadtree indicated in the SPS (Sequence Parameter Set), each quadrant is assigned a flag indicating whether it is split into four quadrants. The leaf blocks produced by the residual quadtree are transform blocks for further processing by the transform codec. The encoder indicates the maximum and minimum luma TB sizes it will use. Splitting is implicit when the CB size is larger than the maximum TB size. Not splitting is implicit when a split would result in a luma TB size smaller than the indicated minimum. The chroma TB size is half the luma TB size in each dimension, except when the luma TB size is 4×4 (in which case a single 4×4 chroma TB is used for the area covered by the four 4×4 luma TBs). In the case of intra-picture predicted CUs, the decoded samples of the nearest neighboring TB (inside or outside the CB) are used as reference data for intra-picture prediction.

[0051] 2.2.2 Summary

[0052] A CTU may be recursively divided into multiple CUs based on increasing depth of the quadtree (e.g., Figure 3B ). Only square CB and TB partitions are specified, where the block can be recursively divided into tetrads, as in Figure 3A shown.

[0053] Mode selection is determined at the CU level. Side information related to the selected mode, such as motion information and intra prediction mode, is signaled at the PU level. Residual information is signaled at the TU level.

[0054] For inter-coded blocks, a PU shall not be larger than a CU, and for intra-coded blocks, a PU shall be equal to a CU.

[0055] For inter-coded blocks, TU can exceed PU, but for intra-coded blocks, TU should be equal to PU.

[0056] 2.3 Quadtree plus binary tree block structure with larger CTU in JEM

[0057] To explore future video codec technologies beyond HEVC, VCEG and MPEG jointly established the Joint Video Exploration Team (JVET) in 2015. Since then, JVET has adopted many new methods and put them into reference software called the Joint Exploration Model (JEM).

[0058] 2.3.1QTBT Block Partition Structure

[0059] Unlike HEVC, the QTBT structure removes the separation of the concepts of CU, PU and TU, and supports more flexibility in the shape of CU partitioning. In the QTBT block structure, the CU can have a square or rectangular shape. In the example, the codec tree unit (CTU) is first partitioned by a quadtree structure. The quadtree leaf nodes are further partitioned by a binary tree structure. There are two types of partitioning in the binary tree partitioning, symmetrical horizontal partitioning and symmetrical vertical partitioning. The binary leaf nodes are called codec units (CUs), and the segmentation is used for prediction and transform processing without any further partitioning. This means that CU, PU and TU have the same block size in the QTBT codec block structure. In JEM, a CU is sometimes composed of codec blocks (CBs) of different color components, for example, a CU contains one luminance CB and two chroma CBs in the case of P slices and B slices in a 4:2:0 chroma format, and sometimes consists of CBs of a single component, for example, a CU contains only one luminance CB or only two chroma CBs in the case of an I slice.

[0060] Define the following parameters for the QTBT segmentation scheme:

[0061] –CTU size: the root node size of the quadtree, the same concept as in HEVC

[0062] –MinQTSize: Minimum allowed quadtree leaf node size

[0063] –MaxBTSize: Maximum allowed binary tree root node size

[0064] –MaxBTDepth: Maximum allowed binary tree depth

[0065] –MinBTSize: minimum allowed binary tree leaf node size

[0066] In one example of a QTBT partitioning structure, the CTU size is set to 128×128 luma samples with two corresponding 64×64 chroma sample blocks, MinQTSize is set to 16×16, MaxBTSize is set to 64×64, MinBTSize (width and height) is set to 4×4, and MaxBTDepth is set to 4. Quadtree partitioning is first applied to the CTU to generate quadtree leaf nodes. Quadtree leaf nodes can have sizes from 16×16 (i.e., MinQTSize) to 128×128 (i.e., CTU size). If the quadtree leaf node is 128×128, it will not be further partitioned through the binary tree because the size exceeds MaxBTSize (i.e., 64×64). Otherwise, the quadtree leaf node can be further partitioned through the binary tree. Therefore, the quadtree leaf node is also the root node of the binary tree, and its binary tree depth is 0. When the binary tree depth reaches MaxBTDepth (i.e., 4), further partitioning is not considered. When a binary tree node has a width equal to MinBTSize (i.e., 4), no further horizontal splitting is considered. Similarly, when a binary tree node has a height equal to MinBTSize, no further vertical splitting is considered. The leaf nodes of the binary tree are further processed by prediction and transform processing without any further splitting. In JEM, the maximum CTU size is 256×256 luma samples.

[0067] Figure 4 (left) shows an example of block segmentation by using QTBT, and Figure 4 (Right) shows the corresponding tree representation. Solid lines indicate quadtree partitioning, and dashed lines indicate binary tree partitioning. In each partition (i.e., non-leaf) node of the binary tree, a flag is signaled to indicate which partition type is used (i.e., horizontal or vertical), where 0 indicates horizontal partitioning and 1 indicates vertical partitioning. For quadtree partitioning, there is no need to indicate the partition type because quadtree partitioning always divides the block horizontally and vertically to produce 4 sub-blocks of the same size.

[0068] In addition, the QTBT scheme supports the ability to have separate QTBT structures for luma and chroma. Currently, for P and B slices, the luma CTB and chroma CTB in a CTU share the same QTBT structure. However, for I slices, the luma CTB is split into CUs using the QTBT structure, and the chroma CTB is split into chroma CUs using another QTBT structure. This means that a CU in an I slice consists of a codec block for the luma component or a codec block for two chroma components, and a CU in a P or B slice consists of codec blocks for all three color components.

[0069] In HEVC, inter prediction for small blocks is restricted to reduce memory access for motion compensation, so that bidirectional prediction is not supported for 4×8 blocks and 8×4 blocks, and inter prediction is not supported for 4×4 blocks. In JEM's QTBT, these restrictions are removed.

[0070] 2.3.2QTBT Summary

[0071] A CTU can be recursively partitioned into multiple CUs based on increasing depth of a quadtree or binary tree. Square and rectangular CBs (width / height equal to 1 / 2 or 2) are specified.

[0072] Mode selection is determined at the CU level. PU and TU are always equal to CU.

[0073] 2.4 Multiple Type Tree (MTT) for VVC

[0074] 2.4.1 Proposals in JVET-D0117

[0075] It is proposed to support tree types other than quadtree and binary tree. In this embodiment, two more ternary tree (TT) partitions are introduced, namely horizontal and vertical center-side ternary trees, such as Figure 5E and Figure 5F shown.

[0076] In some embodiments, a partition in BT / TT can be further divided by BT / TT. Thus, rectangular blocks are allowed.

[0077] Two levels of trees are supported: a region tree (quadtree) and a prediction tree (binary or ternary tree). The CTU is first partitioned using the region tree (RT). The RT leaf can be further partitioned using the prediction tree (PT). The PT leaf can be further partitioned using the PT until the maximum PT depth is reached. The PT leaf is the basic codec unit. For convenience, it is still referred to as a CU. The CU cannot be further partitioned. Prediction and transform are applied to the CU in the same manner as JEM. The entire partitioning structure is named "multi-type tree."

[0078] 2.4.2 Segmentation Tree in VVC

[0079] Similarly, three types of segmentation structures are proposed, namely QT, BT and TT, as Figures 6A-6E As shown in the example. Blocks divided from QT can be further divided into QT / BT / TT. Blocks divided from BT or TT can be further divided into BT or TT. However, blocks divided from BT or TT can no longer be further divided into QT.

[0080] In VVC, several variables are signaled / derived to control the use of different partitions. For example:

[0081] Maximum multi-type tree depth maxMttDepth with offset for luma and chroma, maximum binary tree size maxBtSize / maximum ternary tree size maxTtSize

[0082] Minimum quadtree size MinQtSize / minimum binary tree size MinBtSize / minimum ternary tree size minTtSize

[0083] 7.3.2.1 Sequence Parameter Set RBSP Syntax

[0084]

[0085] Semantics

[0086] sps_max_mtt_hierarchy_depth_inter_tile_groups specifies the default maximum hierarchy depth for codec units resulting from multi-type tree partitioning of quadtree leaves in slice groups of the referenced SPS whose tile_group_type is equal to 0 (B) or 1 (P). When partition_constraints_override_flag is equal to 1, the default maximum hierarchy depth can be overridden by tile_group_max_mtt_hierarchy_depth_luma present in the slice group header of the slice group of the referenced SPS.

[0087] The value of sps_max_mtt_hierarchy_depth_inter_tile_groups should be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY (inclusive).

[0088] sps_max_mtt_hierarchy_depth_intra_tile_groups_luma specifies the default maximum hierarchical depth of codecs resulting from multi-type tree partitioning of quadtree leaves in slice groups of the referenced SPS whose tile_group_type is equal to 2(I). When partition_constraints_override_flag is equal to 1, the default maximum hierarchical depth can be overridden by tile_group_max_mtt_hierarchy_depth_luma present in the slice group header of the slice group of the referenced SPS.

[0089] The value of sps_max_mtt_hierarchy_depth_intra_tile_groups_luma should be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY (inclusive).

[0090] sps_log2_diff_max_bt_min_qt_intra_tile_group_luma specifies the default difference between the maximum size (width or height) of the luma samples of the luma codec blocks that can be partitioned using binary partitioning in the slice group whose tile_group_type is equal to 2 (I) of the reference SPS and the logarithm to the base 2 of the minimum size (width or height) of the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_bt_min_qt_luma present in the slice group header of the slice group referencing the SPS.

[0091] The value of sps_log2_diff_max_bt_min_qt_intra_tile_group_luma shall be in the range of 0 to CtbLog2SizeY-MinQtLog2SizeIntraY (inclusive). When sps_log2_diff_max_bt_min_qt_intra_tile_group_luma is not present,

[0092] The value of sps_log2_diff_max_bt_min_qt_intra_tile_group_luma is inferred to be equal to 0.

[0093] sps_log2_diff_max_tt_min_qt_intra_tile_group_luma specifies the default difference between the maximum size (width or height) of the luma samples of the luma codec blocks that can be partitioned using ternary partitioning in a slice group whose tile_group_type is equal to 2 (I) of the reference SPS and the logarithm to the base 2 of the minimum size (width or height) of the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_tt_min_qt_luma present in the slice group header of the slice group referencing the SPS.

[0094] The value of sps_log2_diff_max_tt_min_qt_intra_tile_group_luma shall be in the range of 0 to CtbLog2SizeY-MinQtLog2SizeIntraY (inclusive). When sps_log2_diff_max_tt_min_qt_intra_tile_group_luma is not present,

[0095] The value of sps_log2_diff_max_tt_min_qt_intra_tile_group_luma is inferred to be equal to 0.

[0096] sps_log2_diff_max_bt_min_qt_inter_tile_group specifies the default difference between the maximum size (width or height) of the luma samples of the luma codec blocks that can be partitioned using binary partitioning and the base-2 logarithm of the minimum size (width or height) of the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU in the slice group whose tile_group_type is equal to 0 (B) or 1 (P) of the reference SPS. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_bt_min_qt_luma present in the slice group header of the slice group referencing the SPS.

[0097] The value of sps_log2_diff_max_bt_min_qt_inter_tile_group shall be in the range of 0 to CtbLog2SizeY-MinQtLog2SizeInterY (inclusive). When sps_log2_diff_max_bt_min_qt_inter_tile_group is not present,

[0098] The value of sps_log2_diff_max_bt_min_qt_inter_tile_group is inferred to be equal to 0.

[0099] sps_log2_diff_max_tt_min_qt_inter_tile_group specifies the default difference between the maximum size (width or height) of the luma samples of the luma codec blocks that can be partitioned using ternary partitioning and the base-2 logarithm of the minimum size (width or height) of the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU in a slice group whose tile_group_type is equal to 0 (B) or 1 (P) of the reference SPS. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_tt_min_qt_luma present in the slice group header of the slice group referencing the SPS.

[0100] The value of sps_log2_diff_max_tt_min_qt_inter_tile_group shall be in the range of 0 to CtbLog2SizeY-MinQtLog2SizeInterY (inclusive). When sps_log2_diff_max_tt_min_qt_inter_tile_group is not present, the value of sps_log2_diff_max_tt_min_qt_inter_tile_group is inferred to be equal to 0.

[0101] sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma specifies the default difference between the base-2 logarithm of the minimum size of luma samples of chroma leaf blocks resulting from quadtree partitioning of chroma CTUs with treeType equal to DUAL_TREE_CHROMA in slice groups with tile_group_type equal to 2(1) of the reference SPS and the base-2 logarithm of the minimum decoded block size of luma samples of chroma CTUs with treeType equal to DUAL_TREE_CHROMA. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_min_qt_min_cb_chroma present in the slice group header of the slice group referencing the SPS. The value of sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma shall be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY, inclusive. When not present, the value of sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma is inferred to be equal to 0. The base-2 logarithm of the minimum size of luma samples of chroma leaf blocks resulting from a quadtree partition of a CTU with treeType equal to DUAL_TREE_CHROMA is derived as follows:

[0102] MinQtLog2SizeIntraC=sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma+MinCbLog2SizeY(728)

[0103] sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma specifies the default maximum hierarchical depth for chroma codec units resulting from multi-type tree partitioning of chroma quadtree leaves with treeType equal to DUAL_TREE_CHROMA in slice groups with tile_group_type equal to 2(1) of the referenced SPS. When partition_constraints_override_flag is equal to 1, the default maximum hierarchical depth can be overridden by tile_group_max_mtt_hierarchy_depth_chroma present in the slice header of the slice group referencing the SPS. The value of sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma shall be in the range of 0 to CtbLog2SizeY - MinCbLog2SizeY, inclusive. When not present, the value of sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma is inferred to be equal to 0.

[0104] sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma specifies the default difference between the maximum size (width or height) of the luma samples of the chroma codec blocks that can be partitioned using binary partitioning in a slice group whose tile_group_type is equal to 2(1) of the reference SPS and the base-2 logarithm of the minimum size (width or height) of the luma samples of the chroma leaf blocks resulting from a quadtree partition of a chroma CTU whose treeType is equal to DUAL_TREE_CHROMA. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_bt_min_qt_chroma present in the slice header of the slice group of the reference SPS. The value of sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeIntraC, inclusive. When sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma is not present, the value of sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma is inferred to be equal to 0.

[0105] sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma specifies the default difference between the maximum size (width or height) of the luma samples of the chroma codec blocks that can be partitioned using ternary partitioning in a slice group whose tile_group_type is equal to 2(1) of the reference SPS and the base-2 logarithm of the minimum size (width or height) of the luma samples of the chroma leaf blocks resulting from a quadtree partitioning of a chroma CTU whose treeType is equal to DUAL_TREE_CHROMA. When partition_constraints_override_flag is equal to 1, the default difference can be overridden by tile_group_log2_diff_max_tt_min_qt_chroma present in the slice header of the slice group of the reference SPS. The value of sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeIntraC, inclusive. When sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma is not present, the value of sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma is inferred to be equal to 0.

[0106] 2.4.2.1 Restrictions on the use of BT and TT

[0107] 2.4.2.1.1 Variable Definition

[0108] tile_group_log2_diff_min_qt_min_cb_luma specifies the difference between the base-2 logarithm of the minimum size among the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU in the current slice group and the base-2 logarithm of the minimum decoded block size among the luma samples of the luma CU. The value of tile_group_log2_diff_min_qt_min_cb_luma should be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY, inclusive. When not present, the value of tile_group_log2_diff_min_qt_min_cb_luma is inferred as follows:

[0109] - If tile_group_type is equal to 2(1), then

[0110] The value of tile_group_log2_diff_min_qt_min_cb_luma is inferred to be equal to sps_log2_diff_min_qt_min_cb_intra_tile_group_luma;

[0111] Otherwise (tile_group_type is equal to 0 (B) or 1 (P)), the value of tile_group_log2_diff_min_qt_min_cb_luma is inferred to be equal to sps_log2_diff_min_qt_min_cb_inter_tile_group.

[0112] tile_group_max_mtt_hierarchy_depth_luma specifies the maximum hierarchical depth of codec units resulting from multi-type tree partitioning of quadtree leaves in the current slice group. The value of tile_group_max_mtt_hierarchy_depth_luma should be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY (inclusive). When not present, the value of tile_group_max_mtt_hierarchy_depth_luma is inferred as follows:

[0113] - if tile_group_type is equal to 2(1), the value of tile_group_max_mtt_hierarchy_depth_luma is inferred to be equal to sps_max_mtt_hierarchy_depth_intra_tile_groups_luma;

[0114] Otherwise (tile_group_type is equal to 0 (B) or 1 (P)), the value of tile_group_max_mtt_hierarchy_depth_luma is inferred to be equal to sps_max_mtt_hierarchy_depth_inter_tile_groups.

[0115] tile_group_log2_diff_max_bt_min_qt_luma specifies the difference between the maximum size (width or height) among the luma samples of the luma codec blocks in the current slice group that can be partitioned using binary partitioning and the base-2 logarithm of the minimum size (width or height) among the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU. The value of tile_group_log2_diff_max_bt_min_qt_luma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeY, inclusive. When not present, the value of tile_group_log2_diff_max_bt_min_qt_luma is inferred as follows:

[0116] - if tile_group_type is equal to 2(1), then the value of tile_group_log2_diff_max_bt_min_qt_luma is inferred to be equal to sps_log2_diff_max_bt_min_qt_intra_tile_group_luma;

[0117] Otherwise (tile_group_type is equal to 0 (B) or 1 (P)), the value of tile_group_log2_diff_max_bt_min_qt_luma is inferred to be equal to sps_log2_diff_max_bt_min_qt_inter_tile_group.

[0118] tile_group_log2_diff_max_tt_min_qt_luma specifies the difference between the maximum size (width or height) of the luma samples of the luma codec blocks in the current slice group that can be partitioned using ternary partitioning and the base-2 logarithm of the minimum size (width or height) of the luma samples of the luma leaf blocks resulting from the quadtree partitioning of the CTU. The value of tile_group_log2_diff_max_tt_min_qt_luma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeY, inclusive. When not present, the value of tile_group_log2_diff_max_tt_min_qt_luma is inferred as follows:

[0119] - if tile_group_type is equal to 2(1), then the value of tile_group_log2_diff_max_tt_min_qt_luma is inferred to be equal to sps_log2_diff_max_tt_min_qt_intra_tile_group_luma;

[0120] Otherwise (tile_group_type is equal to 0 (B) or 1 (P)), the value of tile_group_log2_diff_max_tt_min_qt_luma is inferred to be equal to sps_log2_diff_max_tt_min_qt_inter_tile_group.

[0121] tile_group_log2_diff_min_qt_min_cb_chroma specifies the difference between the base-2 logarithm of the minimum size among the luma samples of the chroma leaf blocks resulting from quadtree partitioning of the chroma CTU with treeType equal to DUAL_TREE_CHROMA in the current slice group and the base-2 logarithm of the minimum decoded block size among the luma samples of its chroma CU with treeType equal to DUAL_TREE_CHROMA. The value of tile_group_log2_diff_min_qt_min_cb_chroma shall be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY, inclusive. When not present, the value of tile_group_log2_diff_min_qt_min_cb_chroma is inferred to be equal to sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma.

[0122] tile_group_max_mtt_hierarchy_depth_chroma specifies the maximum hierarchical depth of codec units in the current slice group resulting from multi-type tree partitioning of quadtree leaves whose treeType is equal to DUAL_TREE_CHROMA. The value of tile_group_max_mtt_hierarchy_depth_chroma shall be in the range of 0 to CtbLog2SizeY-MinCbLog2SizeY, inclusive. When not present, the value of tile_group_max_mtt_hierarchy_depth_chroma is inferred to be equal to sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma.

[0123] tile_group_log2_diff_max_bt_min_qt_chroma specifies the difference between the maximum dimension (width or height) of the luma samples of the chroma codec blocks in the current slice group that can be partitioned using binary partitioning and the base-2 logarithm of the minimum dimension (width or height) of the luma samples of the chroma leaf blocks resulting from a quadtree partitioning of the chroma CTU whose treeType is equal to DUAL_TREE_CHROMA. The value of tile_group_log2_diff_max_bt_min_qt_chroma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeC, inclusive. When not present, the value of tile_group_log2_diff_max_bt_min_qt_chroma is inferred to be equal to sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma.

[0124] tile_group_log2_diff_max_tt_min_qt_chroma specifies the difference between the maximum size (width or height) of the luma samples of the chroma codec blocks in the current slice group that can be partitioned using ternary partitioning and the base-2 logarithm of the minimum size (width or height) of the luma samples of the chroma leaf blocks resulting from a quadtree partitioning of the chroma CTU whose treeType is equal to DUAL_TREE_CHROMA. The value of tile_group_log2_diff_max_tt_min_qt_chroma shall be in the range of 0 to CtbLog2SizeY - MinQtLog2SizeC, inclusive. When not present, the value of tile_group_log2_diff_max_tt_min_qt_chroma is inferred to be equal to sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma.

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

[0126] MinQtLog2SizeY=MinCbLog2SizeY+tile_group_log2_diff_min_qt_min_cb_luma(7-33)

[0127] MinQtLog2SizeC=MinCbLog2SizeY+tile_group_log2_diff_min_qt_min_cb_chroma(7-34)

[0128] MinQtSizeY=1<<MinQtLog2SizeY(7-35)

[0129] MinQtSizeC=1<<MinQtLog2SizeC(7-36)

[0130] MaxBtSizeY=1<<(MinQtLog2SizeY+tile_group_log2_diff_max_bt_min_qt_luma)(7-37)

[0131] MaxBtSizeC=1<<(MinQtLog2SizeC+tile_group_log2_diff_max_bt_min_qt_chroma)(7-38)

[0132] MinBtSizeY=1<<MinCbLog2SizeY(7-39)

[0133] MaxTtSizeY=1<<(MinQtLog2SizeY+tile_group_log2_diff_max_tt_min_qt_luma)(7-40)

[0134] MaxTtSizeC=1<<(MinQtLog2SizeC+tile_group_log2_diff_max_tt_min_qt_chroma)(7-41)

[0135] MinTtSizeY=1<<MinCbLog2SizeY(7-42)

[0136] MaxMttDepthY=tile_group_max_mtt_hierarchy_depth_luma(7-43)

[0137] MaxMttDepthC=tile_group_max_mtt_hierarchy_depth_chroma(7-44)

[0138] log2_ctu_size_minus2 and log2_min_luma_coding_block_size_minus2 are signaled in the SPS.

[0139] log2_ctu_size_minus2 plus 2 specifies the luma codec tree block size for each CTU.

[0140] log2_min_luma_coding_block_size_minus2 plus 2 specifies the minimum luma coding block size.

[0141] The variables CtbLog2SizeY, CtbSizeY, MinCbLog2SizeY, MinCbSizeY, MinTbLog2SizeY, MaxTbLog2SizeY, MinTbSizeY, MaxTbSizeY, PicWidthInCtbsY, PicHeightInCtbsY, PicSizeInCtbsY, PicWidthInMinCbsY, PicHeightInMinCbsY, PicSizeInMinCbsY, PicSizeInSamplesY, PicWidthInSamplesC, and PicHeightInSamplesC are derived as follows:

[0142] CtbLog2SizeY=log2_ctu_size_minus2+2(7-7)

[0143] CtbSizeY=1< <CtbLog2SizeY(7-8)

[0144] MinCbLog2SizeY=log2_min_luma_coding_block_size_minus2+2(7-9)

[0145] MinCbSizeY=1< <MinCbLog2SizeY(7-10)

[0146] MinTbLog2SizeY=2(7-11)

[0147] MaxTbLog2SizeY=6(7-12)

[0148] MinTbSizeY=1< <MinTbLog2SizeY(7-13)

[0149] MaxTbSizeY=1< <MaxTbLog2SizeY(7-14)

[0150] PicWidthInCtbsY = Ceil(pic_width_in_luma_samples÷CtbSizeY) (7-15)

[0151] PicHeightInCtbsY=Ceil(pic_height_in_luma_samples÷CtbSizeY)(7-16)

[0152] PicSizeInCtbsY=PicWidthInCtbsY*PicHeightInCtbsY(7-17)

[0153] PicWidthInMinCbsY=pic_width_in_luma_samples / MinCbSizeY(7-18)

[0154] PicHeightInMinCbsY=pic_height_in_luma_samples / MinCbSizeY(7-19)

[0155] PicSizeInMinCbsY=PicWidthInMinCbsY*PicHeightInMinCbsY(7-20)

[0156] PicSizeInSamplesY=pic_width_in_luma_samples*

[0157] pic_height_in_luma_samples(7-21)

[0158] PicWidthInSamplesC=pic_width_in_luma_samples / SubWidthC(7-22)

[0159] PicHeightInSamplesC=pic_height_in_luma_samples / SubHeightC(7-23)

[0160] [Ed.(BB): Currently, the maximum transform size (64×64 luma samples and the corresponding chroma samples) and the minimum transform size (4×4 luma samples and the corresponding chroma samples) are fixed and await further specification development.]

[0161] 2.4.2.1.2 Allowable binary partitioning processes

[0162] The inputs to this process are:

[0163] -Binary split mode btSplit,

[0164] - Codec block width cbWidth,

[0165] -Codec block height cbHeight,

[0166] - the position (x0, y0) of the top left luma sample of the considered codec block relative to the top left luma sample of the picture,

[0167] -Multi-type tree depth mttDepth,

[0168] - maximum multi-type tree depth maxMttDepth with offset,

[0169] - Maximum binary tree size maxBtSize,

[0170] - Partition index partIdx.

[0171] -The output of this process is the variable allowBtSplit.

[0172] Table 1: Specifications of parallelTtSplit and cbSize based on btSplit

[0173] btSplit == SPLIT_BT_VER btSplit == SPLIT_BT_HOR parallelTtSplit SPLIT_TT_VER SPLIT_TT_HOR cbSize cbWidth cbHeight

[0174] The variables parallelTtSplit and cbSize are derived as shown in Table 1.

[0175] The variable allowBtSplit is derived as follows:

[0176] - allowBtSplit is set equal to FALSE if one or more of the following conditions are true:

[0177] / / Based on the block size and the maximum allowed MTT depth

[0178] -cbSize is less than or equal to MinBtSizeY

[0179] -cbWidth is greater than maxBtSize

[0180] -cbHeight is greater than maxBtSize

[0181] -mttDepth is greater than or equal to maxMttDepth

[0182] Otherwise, if all of the following conditions are true, allowBtSplit is set equal to FALSE

[0183] / / According to the picture boundary (there is no vertical BT at the bottom picture boundary and the lower right picture boundary)

[0184] -btSplit equals SPLIT_BT_VER

[0185] -y0+cbHeight is greater than pic_height_in_luma_samples

[0186] Otherwise, if all of the following conditions are true, allowBtSplit is set equal to FALSE

[0187] / / According to the picture boundary (there is no horizontal BT at the right picture boundary)

[0188] -btSplit equals SPLIT_BT_HOR

[0189] -x0+cbWidth is greater than pic_width_in_luma_samples

[0190] -y0+cbHeight is less than or equal to pic_height_in_luma_samples

[0191] Otherwise, if all of the following conditions are true, allowBtSplit is set equal to FALSE:

[0192] / / According to the TT segmentation at the previous level (mttDepth-1)

[0193] -mttDepth is greater than 0

[0194] -partIdx is equal to 1

[0195] -MttSplitMode[x0][y0][mttDepth-1] equals parallelTtSplit

[0196] / / According to the transform size (for example, when MaxTbSizeY is equal to 64, for 64×128, there is no vertical BT; for 128×64, there is no horizontal BT)

[0197] Otherwise, if all of the following conditions are true, allowBtSplit is set equal to FALSE

[0198] -btSplit equals SPLIT_BT_VER

[0199] -cbWidth is less than or equal to MaxTbSizeY

[0200] -cbHeight is greater than MaxTbSizeY

[0201] Otherwise, if all of the following conditions are true, allowBtSplit is set to FALSE.

[0202] -btSplit equals SPLIT_BT_HOR

[0203] -cbWidth is greater than MaxTbSizeY

[0204] -cbHeight is less than or equal to MaxTbSizeY

[0205] Otherwise, allowBtSplit is set equal to TRUE.

[0206] 2.4.2.1.3 Allowable ternary partitioning process

[0207] The inputs to this process are:

[0208] - ternary split mode ttSplit,

[0209] - Codec block width cbWidth,

[0210] -Codec block height cbHeight,

[0211] - the position (x0, y0) of the top left luma sample of the considered codec block relative to the top left luma sample of the picture,

[0212] -Multi-type tree depth mttDepth

[0213] - maximum multi-type tree depth maxMttDepth with offset,

[0214] - Maximum binary tree size maxTtSize.

[0215] The output of this procedure is the variable allowTtSplit.

[0216] Table 2: Specification of cbSize based on ttSplit

[0217] ttSplit==SPLIT_TT_VER ttSplit==SPLIT_TT_HOR cbSize cbWidth cbHeight

[0218] The variable cbSize is derived as shown in Table 2.

[0219] The variable allowTtSplit is derived as follows:

[0220] - allowTtSplit is set to FALSE if one or more of the following conditions are true: / / based on the chunk size

[0221] -cbSize is less than or equal to 2*MinTtSizeY

[0222] -cbWidth is greater than Min(MaxTbSizeY,maxTtSize)

[0223] -cbHeight is greater than Min(MaxTbSizeY,maxTtSize)

[0224] / / According to the maximum allowed MTT depth

[0225] -mttDepth is greater than or equal to maxMttDepth

[0226] / / According to whether it is at the border of the picture

[0227] -x0+cbWidth is greater than pic_width_in_luma_samples

[0228] -y0+cbHeight is greater than pic_height_in_luma_samples

[0229] - Otherwise, allowTtSplit is set equal to TRUE.

[0230] 2.5 Segmentation Tree Structure in AVS3

[0231] In AVS3, extended quadtree (EQT) partitioning is adopted, which further extends the QTBT scheme and increases partitioning flexibility. More specifically, EQT divides the parent CU into four child CUs of different sizes, which can appropriately model local image content that cannot be accurately characterized by QTBT. At the same time, EQT partitioning allows interleaving with BT partitioning to enhance adaptability.

[0232] Using EQT partitioning, the parent CU is divided into four sub-CUs of different sizes. Figure 7A As shown in , EQT divides the M×N parent CU into two M×N / 4CUs and two M / 2×N / 2CUs in the horizontal direction. Figure 7B As shown, EQT vertical partitioning generates two N×M / 4 CUs and two M / 2×N / 2 CUs. In particular, the EQT sub-block size is always a power of 2, so no additional transformation is required.

[0233] In the QTBT structure, the QT split flag is first signaled to indicate whether the current CU is QT split. In this way, when the flag is false, the second signal will be encoded to indicate whether the current CU split mode is non-split or BT split. For BT split CU, the third bit (DIR) is signaled to distinguish horizontal BT or vertical BT split. When EQT split is introduced, in the case where both BT and EQT are available, an additional bit called isEQT is signaled to indicate whether it is EQT split, such as Figure 8 shown.

[0234] 2.6UQT

[0235] In our P1809119401H, we proposed an unsymmetrical quadtree (UQT) partitioning. Using UQT, a block of dimension W×H is partitioned into four partitions of dimensions W1×H1, W2×H2, W3×H3, and W4×H4, where W1, W2, W3, W4, H1, H2, H3, and H4 are integers. All parameters are powers of 2. For example, W1=2N1, W2=2N2, W3=2N3, W4=2N4, H1=2M1, H2=2M2, H3=2M3, and H4=2M4. Some examples are given in Figures 9A-9F Shown in.

[0236] 3. Shortcomings and problems of existing systems

[0237] Although the QT / BT / TT codec tree structure in VVC is very flexible, there are still certain partitioning patterns that cannot be obtained by QT / BT / TT / EQT / UQT.

[0238] 4. Exemplary Method for Quinary Tree Partitioning

[0239] To address this problem, several methods have been proposed to introduce other types of partitioning structures that can divide a block into more than four partitions.

[0240] The following detailed invention should be considered as an example to explain the general concept. These embodiments should not be interpreted in a narrow sense. In addition, these embodiments can be combined in any way.

[0241] In the following discussion, a partition tree may indicate QT, BT, TT, unsymmetrical quadtree (UQT), EQT, or others. A partition / split direction may indicate horizontal partitioning, vertical partitioning, diagonal partitioning, or others. A partition is represented by its partition tree type and partition direction.

[0242] QT, BT, TT, UQT or EQT may refer to "QT partition", "BT partition", "TT partition", "UQT partition" and "EQT partition" respectively.

[0243] In the following discussion, “partition” and “segmentation” have the same meaning. The proposed method can also be applied to existing segmentation trees.

[0244] Definition of the proposed segmentation type

[0245] 1. A quinary tree (QUI-T) partitioning is proposed. Using QUI-T, a block of dimension W×H is divided into five smaller blocks. When the indication to use this partitioning is true, such a block is directly divided into five smaller blocks (also called sub-blocks). The smaller blocks can be regarded as coding units / prediction units / transform units. Each dimension of the smaller block can be represented by W i ×H i (i is 0...4, indicating the partition index) represents, and W i 、H i All are integers.

[0246] a. In one example, each smaller block can be further divided into even smaller blocks, such as in a recursive manner.

[0247] b. In one example, all dimensions are powers of 2.

[0248] i. For example, W0=2N0, W1=2N1, W2=2N2, W3=2N3, W4=2N4, H0=2M0, H1=2M1, H2=2M2, H3=2M3, H4=2M4.

[0249] c. In one example, QUI-T divides a block in both horizontal and vertical directions. This is called mixed direction. Figure 10A 、 Figure 10B and Figure 10D Some examples are given.

[0250] i. For example, at least one of Wi is not equal to W.

[0251] ii. For example, at least one of Hi is not equal to H.

[0252] d. In one example, QUI-T divides a block only in the vertical direction.

[0253] i. For example, H0=H1=H2=H3=H4=H. Figure 10C An example is given.

[0254] e. In one example, QUI-T divides a block only in the horizontal direction.

[0255] i. For example, W0=W1=W2=W3=W4=W. Figure 10E An example is given.

[0256] f. In one example, one of the partitions (size equal to W x ×H x ) has different block sizes compared to other partitions.

[0257] i. In one example, the other four partitions have the same size.

[0258] ii. In one example, W x =1 / 2W and W y =1 / 8W(y!=x), wherein x is a value in the range [0,4]. Alternatively, further, x is equal to 1 or 3.

[0259] 1. Figure 10C An example is given where W3 = 1 / 2W, Wy = 1 / 8W (y! = 3).

[0260] iii. In one example, H x =1 / 2H and H y =1 / 8H(y!=x). Alternatively, furthermore, x is equal to 1 or 3.

[0261] iv. In one example, W x =W-((W / 5)<<2) and W y =W / 5(y!=x), where x is a value in the range of [0,4].

[0262] v. In one example, W x =W-((W / M)<<2) and W y =W / M(y!=x) where M is an integer such as 8, 16, 32, or 64.

[0263] g. In one example, two partitions in a partition may have equal size (size equal to W x ×H x ), the other partitions have sizes equal to but different from these two partitions.

[0264] i. In one example, W x =1 / 8W, W y = 1 / 4W (for all y where y != x). Alternatively, further, x is equal to 0 and 3. Alternatively, further, x is equal to 0 and 4. Alternatively, further, x is equal to 1 and 3. Alternatively, further, x is equal to 1 and 4.

[0265] 1. Where W1=W3=1 / 8W and W y =1 / 4W(y!=3&&y!=1).

[0266] ii. In one example, Hx =1 / 8H and H y = 1 / 4H (for all y where y != x). Alternatively, further, x is equal to 0 and 3. Alternatively, further, x is equal to 0 and 4. Alternatively, further, x is equal to 1 and 3. Alternatively, further, x is equal to 1 and 4.

[0267] h. In one example, two partitions in a partition may be of equal size (size equal to W x ×H x ), the other three partitions can have different sizes.

[0268] i. In one example, for two partitions of equal size, W x =1 / 16W; and W i =2 / 16W; W j =4 / 16W, and W k =8 / 16W, where i, j, k are not equal to x. 1. Where W0 = W4 = 1 / 16W; W1 = 2 / 16W; W2 = 4 / 16W and W3 = 8 / 16W.

[0269] ii. In one example, for two partitions of equal size, H x =1 / 16H; and

[0270] H i =2 / 16W; H j =4 / 16W, and H k =8 / 16W, where i, j, and k are not equal to x.

[0271] iii. Alternatively, two of the five partitions may be of equal size (size equal to W x ×H x ), and two of the remaining three partitions have the same size.

[0272] i. In the above and following descriptions, 1 / 16W or 1 / 8W means 1 / 16×W or 1 / 8×W, or is expressed as W / 16 or W / 8.

[0273] j. In one example, W0=W4=W / 8 and W1=W2=W3=W / 4, H0=H1=H2=H3=H4=H.

[0274] k. In one example, H0=H4=H / 8 and H1=H2=H3=H / 4, W0=W1=W2=W3=W4=W.

[0275] 1. In one example, when the current block is partitioned by quinary partitioning, one or more sub-blocks are not allowed to perform one or more partitions.

[0276] i. For example, if the current block is divided into five sub-blocks by quinary partitioning: B0: W / 8×H, B1: W / 4×H, B2: W / 4×H, B3: W / 4×H, B4: W / 8×H, then:

[0277] 1. In one example, Bx is not allowed to be partitioned by vertical BT, where x can be one or some of 0, 1, 2, 3, 4;

[0278] 2. In one example, Bx is not allowed to be partitioned by vertical TT, where x can be one or more of 0, 1, 2, 3, 4;

[0279] 3. In one example, Bx is not allowed to be partitioned by horizontal BT, where x can be one or some of 0, 1, 2, 3, 4;

[0280] 4. In one example, Bx is not allowed to be partitioned by horizontal TT, where x can be one or some of 0, 1, 2, 3, 4;

[0281] 5. In one example, Bx is not allowed to be partitioned by QT, where x can be one or some of 0, 1, 2, 3, 4;

[0282] ii. For example, if the current block is divided into five sub-blocks by quinary partitioning: B0: W×H / 8, B1: W×H / 4, B2: W×H / 4, B3: W×H / 4, B4: W×H / 8, then:

[0283] 1. In one example, Bx is not allowed to be partitioned by horizontal BT, where x can be one or some of 0, 1, 2, 3, 4;

[0284] 2. In one example, Bx is not allowed to be partitioned by horizontal TT, where x can be one or some of 0, 1, 2, 3, 4;

[0285] 3. In one example, Bx is not allowed to be partitioned by vertical BT, where x can be one or some of 0, 1, 2, 3, 4;

[0286] 4. In one example, Bx is not allowed to be partitioned by vertical TT, where x can be one or some of 0, 1, 2, 3, 4;

[0287] 5. In one example, Bx is not allowed to be partitioned by QT, where x can be one or some of 0, 1, 2, 3, 4;

[0288] m. The above method can be extended to other hexatree, septenarytree, and octonarytree partitions (SnT, StT, OctT), where a block can be divided into 6, 7, or 8 smaller blocks. An example of hexatree partitioning is given in Figure 11A and Figure 11B Shown in.

[0289] n. Figures 10A-10E Some exemplary segmentations are depicted in .

[0290] o. The codec order (indicated by PIdx 0..4) can be Figures 10A-10E The definitions are different.

[0291] i. The encoding and decoding order of a QUI-T pattern can be predefined.

[0292] ii. Alternatively, multiple codec orders may be predefined for a QUI-T pattern, and a block may select one of them, such as via signaling of the selected codec order or a derived indication at the decoder side.

[0293] Interaction with other segmentation types

[0294] 2. A block divided into sub-blocks by QUI-T may be divided from the parent block by one or some specific kinds of partitioning methods.

[0295] a. A block that can be allowed to be QUI-T split can be a block generated by QT or BT or TT or QUI-T split.

[0296] b. For example, a block that is partitioned into sub-blocks via QUI-T can only be partitioned from its parent block via QT.

[0297] c. The block that allows QUI-T splitting can be the root block.

[0298] 3. A block partitioned from a parent block by QUI-T may be further partitioned into sub-blocks by one or more other partition types (such as QT, BT, TT, QUI-T, UQT).

[0299] a. For example, a block divided from a parent block by QUI-T can be further divided into child blocks by BT and / or TT.

[0300] b. For example, a block divided from a parent block by QUI-T can be divided by BT and / or TT and / or QUI-

[0301] T (but not QT) is further divided into sub-blocks.

[0302] c. For example, a block partitioned from a parent block by QUI-T may be further partitioned into child blocks by QUI-T and / or QT (but not by BT / TT).

[0303] d. For example, a block divided from a parent block by QUI-T cannot be further divided into child blocks by QT.

[0304] e. Alternatively, the QUI-T partitioned blocks may not be further partitioned into sub-blocks.

[0305] 4. When a parent block is partitioned into sub-blocks via QUI-T, the partition depth of the sub-blocks can be derived from the partition depth of the parent block.

[0306] a. In one example, since the division of QUI-T can be used to update QT / BT / TT / QUI-

[0307] T / MTT depth.

[0308] i. In one example, the QT depth of one or all child blocks is equal to the QT depth of the parent block plus 1.

[0309] ii. In one example, the BT depth of one or all child blocks is equal to the BT depth of the parent block plus 1.

[0310] iii. In one example, the TT depth of one or all child blocks is equal to the TT depth of the parent block plus 1.

[0311] iv. In one example, the QUI-T depth of one or all child blocks is equal to the QUI-T depth of the parent block plus 1.

[0312] v. In one example, the MTT depth of one or all child blocks is equal to the MTT depth of the parent block plus 1.

[0313] 1. For example, if a parent block is divided into child blocks through BT, the MTT depth of the child blocks is equal to the MTT depth of the parent block plus 1.

[0314] 2. For example, if a parent block is divided into sub-blocks by TT, the MTT depth of the sub-blocks is equal to the MTT depth of the parent block plus 1.

[0315] b. In one example, the QUI-T / BT / TT / QT / MTT depth increment may be different for different sub-blocks.

[0316] i. The depth increment depends on the ratio of the child block to the parent block.

[0317] Limitations of Use of QUI-T

[0318] 5. In one example, the maximum / minimum block size that can be allowed for QUI-T segmentation and / or the maximum bit depth that can be allowed for QUI-T segmentation and / or the maximum depth that can be set in SPS / PPS / VPS / APS /

[0319] Signaling notification in sequence header / picture header / slice header / slice group header / CTU row / region, etc.

[0320] a. The maximum / minimum block size that can allow QUI-T segmentation and / or the maximum depth that can allow QUI-T segmentation can be derived from other values, such as the depth of MTT or the depth of QT.

[0321] b. The largest block that allows QUI-T partitioning can be the largest codec block (codec tree block or codec tree unit).

[0322] c. For example, the largest block allowed for QUI-T segmentation may be a virtual pipeline data unit (VPDU).

[0323] d. In one example, the maximum / minimum block size that a QUI-T partition may be allowed for and / or the maximum depth that a QUI-T partition may be allowed for may depend on the profile / level / tier of the standard.

[0324] e. In one example, the maximum / minimum block size that may allow QUI-T partitioning and / or the maximum depth that may allow QUI-T partitioning may be derived, such as the same for QT partitioning.

[0325] f. In one example, the maximum / minimum block size that can be allowed for QUI-T partitioning and / or the maximum depth that can be allowed for QUI-T partitioning can depend on whether slice group slice / slice type / color component / dual tree is enabled.

[0326] g. In one example, the maximum / minimum block size that may allow QUI-T segmentation and / or the maximum depth that may allow QUI-T segmentation may be different for different QUI-T patterns.

[0327] h. When a block is divided according to QUI-T, the corresponding depth of the QUI-T of a smaller block may be adjusted accordingly (eg, increased by 1).

[0328] i. Alternatively, the corresponding depth of a particular partition (eg, QT) of a smaller block may be adjusted accordingly (eg, increased by 1).

[0329] ii. Alternatively, the corresponding MTT depth of a smaller block may be adjusted accordingly (eg, increased by 1).

[0330] iii. Adjustment of the corresponding depths of different smaller blocks can be done in the same way (eg, increase by 1).

[0331] 1. Alternatively, the adjustment of the corresponding depths of different smaller blocks may be done in different ways (eg, increasing by 1). For example, the adjustment depends on the block dimensions of the smaller block.

[0332] 6. If a partitioned sub-block spans multiple Virtual Pipe Data Units (VPDUs), QUI-T is not allowed.

[0333] a. Alternatively, QUI-T is still allowed, however, such sub-blocks are forced to be further divided until no sub-block spans more than one VPDU.

[0334] 7. If the width / height of the current block (or any partitioned sub-block) meets certain conditions, QUI-T is not allowed. (Assume that the width and height of the current block are W and H, and T1, T2 and T are some integers).

[0335] a. If W>=T1 and H>=T2, then QUI-T is not allowed;

[0336] b. If W>=T1 or H>=T2, QUI-T is not allowed;

[0337] c. If W <= T1 and H <= T2, then QUI-T is not allowed;

[0338] d. If W <= T1 or H <= T2, QUI-T is not allowed;

[0339] e. If W×H<=T, then QUI-T is not allowed;

[0340] f. If W×H>=T, then QUI-T is not allowed;

[0341] g. If H <= T, then horizontal QUI-T is not allowed; for example, T=16.

[0342] h. If H>=T, then horizontal QUI-T is not allowed; for example, T=128.

[0343] i. If W <= T, then vertical QUI-T is not allowed; for example, T=16.

[0344] j. If W>=T, vertical QUI-T is not allowed; for example, T=128.

[0345] k. T1, T2, and T may be signaled from the encoder to the decoder using VPS / SPS / PPS / picture header / slice header / slice group header / slice header.

[0346] 1. T1, T2 and T can depend on the color components. For example, for the luminance and chrominance components, T1,

[0347] T2 and T may be different.

[0348] i. In one example, the signaled thresholds such as T1, T2, and / or T may be common to both QUI-T and TT.

[0349] ii. In one example, the signaled thresholds such as T1, T2 and / or T may be common to both QUI-T and BT.

[0350] m. T1, T2, and T may depend on whether the luma codec tree and the chroma codec tree are separate. For example, if the luma codec tree and the chroma codec tree are separate, T1, T2, and T may be different for luma and chroma components.

[0351] n. Alternatively, when at least one sub-block does not support transform due to QUI-T, QUI-T partitioning is invalid.

[0352] o. Alternatively, when the depth of a block exceeds the allowed depth of QUI-T partitioning, the QUI-T partitioning is invalid.

[0353] p. Alternatively, when any sub-block size is smaller than the allowed block size due to QUI-T partitioning, QUI-T partitioning is invalid.

[0354] 8. If the width / height of the current block (or any partitioned sub-block) meets certain conditions, QUI-T is allowed. (Assume that the width and height of the current block are W and H, and T1, T2 and T are some integers).

[0355] a. If W>=T1 and H>=T2, then QUI-T is allowed;

[0356] b. If W>=T1 or H>=T2, QUI-T is allowed;

[0357] c. If W <= T1 and H <= T2, then QUI-T is allowed;

[0358] d. If W <= T1 or H <= T2, QUI-T is allowed;

[0359] e. If W×H<=T, then QUI-T is allowed;

[0360] f. If W×H>=T, then QUI-T is allowed;

[0361] g. If H <= T, then allow horizontal QUI-T; for example, T = 64.

[0362] h. If H>=T, then horizontal QUI-T is allowed; for example, T=32.

[0363] i. If W <= T, vertical QUI-T is allowed; for example, T=64.

[0364] j. If W>=T, vertical QUI-T is allowed; for example, T=32.

[0365] k. T1, T2, and T may be signaled from the encoder to the decoder using VPS / SPS / PPS / picture header / slice header / slice group header / slice header.

[0366] i. In one example, the signaled thresholds such as T1, T2, and / or T may be common to both QUI-T and TT.

[0367] ii. In one example, the signaled thresholds such as T1, T2 and / or T may be common to both QUI-T and BT.

[0368] 1. T1, T2, and T can depend on the color component. For example, T1, T2, and T can be different for luma and chroma components.

[0369] m. T1, T2, and T may depend on whether the luma codec tree and the chroma codec tree are separate. For example, if the luma codec tree and the chroma codec tree are separate, T1, T2, and T may be different for luma and chroma components.

[0370] 9. If the depth of the current block meets certain conditions, QUI-T is not allowed. The depth of the current block can refer to QT depth, BT depth, TT depth, QUI-T depth or MTT depth.

[0371] a. If the partition depth <= T, QUI-T is not allowed;

[0372] b. If the partition depth is greater than or equal to T, QUI-T is not allowed;

[0373] c. If QT partition depth <= T, QUI-T is not allowed;

[0374] d. If QT partition depth >= T, QUI-T is not allowed;

[0375] e. If the BT partition depth is greater than or equal to T, QUI-T is not allowed;

[0376] f. If the BT partition depth <= T, QUI-T is not allowed;

[0377] g. If the TT partition depth is greater than or equal to T, QUI-T is not allowed;

[0378] h. If TT partition depth <= T, QUI-T is not allowed;

[0379] i. If QUI-T partition depth <= T, then QUI-T is not allowed;

[0380] j. If the QUI-T partition depth is greater than or equal to T, QUI-T is not allowed;

[0381] k. If the MTT partition depth <= T, QUI-T is not allowed;

[0382] l. If the MTT partition depth is greater than or equal to T, QUI-T is not allowed;

[0383] mT can be signaled from the encoder to the decoder using VPS / SPS / PPS / picture header / slice header / slice group header / slice header.

[0384] nT can depend on the color component. For example, T1, T2 and T can be different for luma and chroma components.

[0385] oT may depend on whether the luma codec tree and the chroma codec tree are separate. For example, if the luma codec tree and the chroma codec tree are separate, T1, T2, and T may be different for luma and chroma components.

[0386] 10. If the depth of the current block meets certain conditions, QUI-T is allowed. The depth of the current block can refer to QT depth, BT depth, TT depth, QUI-T depth or MTT depth.

[0387] a. If the partition depth <= T, QUI-T is allowed;

[0388] b. If the partition depth is greater than or equal to T, QUI-T is allowed;

[0389] c. If QT partition depth <= T, then QUI-T is allowed;

[0390] d. If QT partition depth >= T, QUI-T is allowed;

[0391] e. If BT partition depth >= T, QUI-T is allowed;

[0392] f. If BT partition depth <= T, QUI-T is allowed;

[0393] g. If TT partition depth >= T, QUI-T is allowed;

[0394] h. If TT partition depth <= T, QUI-T is allowed;

[0395] i. If QUI-T partition depth <= T, then QUI-T is allowed;

[0396] j. If QUI-T partition depth >= T, then QUI-T is allowed;

[0397] k. If the MTT partition depth <= T, QUI-T is allowed;

[0398] l. If the MTT partition depth is greater than or equal to T, QUI-T is allowed;

[0399] mT can be signaled from the encoder to the decoder using VPS / SPS / PPS / picture header / slice header / slice group header / slice header.

[0400] nT can depend on the color components. For example, for luma and chroma components, T1, T2, and T

[0401] It can be different.

[0402] oT may depend on whether the luma codec tree and the chroma codec tree are separate. For example, if the luma codec tree and the chroma codec tree are separate, T1, T2, and T may be different for luma and chroma components.

[0403] 11. Whether and how to use QUI-T may depend on the location of the current block. For example, whether and how to use QUI-T may depend on whether the current block crosses a picture / slice / slice group boundary.

[0404] a. In one example, if the current block crosses the bottom boundary of a picture / slice / slice group, vertical QUI-T is not allowed.

[0405] b. In one example, if the current block crosses the bottom boundary of a picture / slice / slice group, horizontal QUI-T is not allowed.

[0406] c. In one example, if the current block crosses the picture / slice / slice group right boundary, vertical QUI-T is not allowed.

[0407] d. In one example, if the current block crosses the picture / slice / slice group right boundary, horizontal QUI-T is not allowed.

[0408] e. In one example, if the current block crosses the picture / slice / slice group right boundary, mixed QUI-T may not be allowed.

[0409] f. In one example, if the current block crosses the bottom boundary of a picture / slice / slice group, mixed QUI-T may not be allowed.

[0410] g. In one example, if a sub-block partitioned by QUI-T is completely outside a picture / slice / slice group, the sub-block can be omitted in the encoding / decoding process.

[0411] h. In one example, if the sub-blocks partitioned by QUI-T are partially outside the picture / slice / slice group, the following may apply:

[0412] i. Parts outside the picture can be omitted during the encoding / decoding process.

[0413] ii. Parts within the image can be further divided.

[0414] iii. Parts within a picture can be encoded and decoded as CUs.

[0415] 1. Whether a part of the picture is encoded or decoded as a CU may depend on the width (w) of the part

[0416] and height (h).

[0417] a. In one example, if w = 2n w , h=2n h , the part within the picture can be encoded and decoded as CU, where n w and n h is an integer.

[0418] i. In one example, if any sub-block divided by QUI-T is partially / entirely in the picture / slice /

[0419] QUI-T is not allowed outside the slice group.

[0420] 12. When QUI-T or certain QUI-T patterns are not allowed, the signaling for indicating the use of the pattern may also be skipped.

[0421] a. Alternatively, it can still be signaled, but constrained to be false in the conforming bitstream.

[0422] 13. When a sub-block is partitioned from QUI-T, the sub-block is not allowed to be further partitioned using one or more of the following partitioning methods, such as:

[0423] a.QT

[0424] b. Horizontal BT

[0425] c. Vertical BT

[0426] d. Horizontal TT

[0427] e. Vertical BT

[0428] f. Horizontal UQT

[0429] g.Vertical UQT

[0430] h.QUI-T

[0431] We propose that QUI-T can be applied only to leaf nodes, e.g., when a block is not further partitioned according to other partitions.

[0432] i. In one example, a flag may be signaled to inform the leaf node whether to use QUI-T.

[0433] i. Alternatively, in addition, an indication of which type of QUI-T may be further signaled.

[0434] j. Alternatively, disabling of QUI-T or an indication of which type of QUI-T may be signaled to the leaf nodes.

[0435] Instructions for use of QUI-T

[0436] 14. Whether to apply QUI-T and / or which QUI-T to apply can be signaled from the encoder to the decoder.

[0437] a. In one example, it can be signaled in VPS / SPS / PPS / sequence header / picture header / slice header / slice group header / slice header to indicate whether QUI-T can be applied.

[0438] b. In one example, it can be signaled in the VPS / SPS / PPS / sequence header / picture header / slice header / slice group header / slice header to indicate which QUI-T can be applied.

[0439] c. In one example, it may be signaled in the block to indicate whether QUI-T is used to partition the block.

[0440] d. In one example, it can be signaled in the block to indicate which QUI-T to use

[0441] to divide the block.

[0442] e. In one example, different QUI-T sets can be designed for different block shapes / sizes.

[0443] f. In one example, different QUI-T sets can be designed for pictures / slices / strips with different temporal layers.

[0444] g. In one example, whether or how QUI-T is applied may depend on video resolution / picture resolution / codec mode / video characteristics (screen content or camera-captured sequence or mixed content) / slice type / picture type / slice group type / low latency check flag.

[0445] 15. A syntax element may be signaled to indicate no partition or partitioning (including partitioning tree type and partitioning direction).

[0446] a. Alternatively, one syntax element may be signaled first to indicate whether to split; and another syntax element may be signaled to indicate the partition.

[0447] 16. The indication of a partition may be represented by two syntax elements: the selected partition tree type may be signaled first, followed by the partition direction if necessary.

[0448] a. In one example, an index of the partition tree type can be signaled in a block to indicate whether the block is partitioned by QT, partitioned by QUI-T, or not partitioned.

[0449] i. Alternatively, in addition, the division direction (horizontal / vertical / mixed direction) and / or division pattern may be further signaled.

[0450] b. In one example, the index of the partition tree type can be signaled in the block to indicate whether the block is partitioned by BT, TT, or QUI-T.

[0451] i. For example, the index may be signaled conditionally, such as only when at least one of BT, TT, and QUI-T is valid for the block.

[0452] ii. Alternatively, in addition, the division direction (horizontal / vertical) and / or division pattern may be further signaled.

[0453] c. Alternatively, an indication of the split direction may be signaled first, followed by the partition tree type (such as QT, TT, QUI-T).

[0454] i. In one example, a flag is signaled in the block to indicate whether the block is vertically or horizontally partitioned. Vertical partitioning can be BT vertical partitioning, TT vertical partitioning, or QUI-T vertical partitioning. Horizontal partitioning can be BT horizontal partitioning, TT horizontal partitioning, or QUI-T horizontal partitioning.

[0455] ii. For example, this flag is signaled only when the block is divided by BT or TT or QUI-T.

[0456] iii. For example, this flag is signaled only when both vertical and horizontal partitioning are valid for the block.

[0457] 1. If only vertical partitioning is valid, this flag is not signaled and horizontal partitioning is inferred to be used.

[0458] 2. If only horizontal partitioning is valid, this flag is not signaled and vertical partitioning is inferred to be used.

[0459] d. In one example, a binary code is signaled in the block to indicate which type of partitioning is used (BT, TT, or a QUI-T). In the following examples, X represents 0 or 1, and Y = ~X (if X = 0, then Y = 1, and if X = 1, then Y = 0).

[0460] i. In one example, the candidate BT, TT or QUI-T to be signaled are all vertically partitioned or horizontally partitioned according to previously signaled or derived information.

[0461] ii. In one example, a first flag is signaled to indicate whether to use QUI-T. For example, the binary codewords representing BT, TT, QUI-T1, QUI-T2, QUI-T3, and QUI-T4 are XX, XY, YXX, YXY, YYX, and YYY, respectively.

[0462] 1. In an alternative example, the binary code words representing BT, TT, and QUI-T1 are XX, XY, and Y, respectively.

[0463] iii. In one example, truncated unary codes are applied. For example, BT, TT, QUI-

[0464] The binary code words for T1, QUI-T2, QUI-T3, and QUI-T4 are X, YX, YYX, YYYX, YYYYX, YYYYY, respectively.

[0465] iv. In one example, a first flag is signaled to indicate whether BT is used. If BT is not used, a second flag is signaled to indicate whether QUI-T is used. If QUI-T is used, the type of QUI-T used is further signaled. For example, the binary codewords representing BT, TT, QUI-T1, QUI-T2, QUI-T3, and QUI-T4 are X, YX, YYXX, YYXY, YYYX, and YYYY, respectively.

[0466] 17. In one example, how to signal which partitioning to use in a block may depend on which partitioning (including partitioning tree type and / or partitioning direction) is valid for the block. In the following examples, X represents 0 or 1, and Y = ~X (if X = 0, then Y = 1, and if X = 1, then Y = 0).

[0467] a. In one example, the candidate BT, TT or QUI-T to be signaled are all vertically partitioned or horizontally partitioned according to previously signaled or derived information.

[0468] b. For example, disallowed or invalid partitions cannot be signaled from the encoder to the decoder, ie there is no codeword to indicate disallowed or invalid partitions.

[0469] c. In one example, if only one partitioning from BT, TT and QUI-T is valid, the binary code indicating which partitioning (BT, TT or one of QUI-T) is used is not signaled.

[0470] d. In one example, if only two partitions from BT, TT and QUI-T are valid, a flag is signaled to indicate which of the two valid partitions to use.

[0471] e. In one example, the code indicating which partition (BT, TT, or a QUI-T) is binarized into a truncated unary code.

[0472] i. For example, the maximum value of a truncated unary code is N-1, where N is the number of valid partitions (BT, TT, and QUI-T).

[0473] ii. For example, no codeword indicates an invalid partition. In other words, invalid partitions are skipped when building the codeword table.

[0474] f. In one example, if no QUI-T is active, the flag indicating whether QUI-T is used is not signaled and is inferred to be false. For example, the binary codewords representing BT and TT are X and y, respectively.

[0475] g. In one example, if only one QUI-T is valid and the use of QUI-T is signaled, no further information is signaled to indicate which QUI-T is used.

[0476] A valid QUI-T is used implicitly.

[0477] h. In one example, if only two types of QUI-T are valid and signaling is used

[0478] QUI-T, a flag is signaled to indicate which QUI-T to use.

[0479] i. In one example, if only three types of QUI-T are valid and signaling is used, a message is signaled to indicate which QUI-T to use. For example, the binary code words representing the three QUI-Ts are X, YX, and YY, respectively.

[0480] j. In one example, the binarization and / or signaling method does not change depending on which partition is valid in the block. Invalid partitions cannot be selected in a conforming bitstream.

[0481] 18. The indication of segmentation may be encoded or decoded using arithmetic coding with one or more contexts.

[0482] a. In one example, only part of the bits of a bit string may be encoded or decoded using the context, and the remaining bits may be encoded or decoded using a bypass mode (ie, without using the context).

[0483] b. Alternatively, all bits of the bit string can be encoded or decoded using the context.

[0484] c. Alternatively, all bits of the bit string can be encoded or decoded in bypass mode.

[0485] d. For bits encoded and decoded with context, one or more contexts may be used.

[0486] e. The context may depend on:

[0487] i. The position or index of a bit.

[0488] ii. Segmentation of spatial / temporal neighboring blocks.

[0489] iii. The current partition depth of the current block (eg, QT depth / BT depth / TT depth / QUI-

[0490] T depth / MTT depth).

[0491] iv. Partition depth of spatial / temporal neighboring blocks and / or spatial / temporal non-neighboring blocks (e.g., QT depth / BT depth / TT depth / QUI-T depth / MTT depth).

[0492] v. Coding and decoding mode of spatial / temporal neighboring blocks.

[0493] vi. Width / height of spatial / temporal neighborhood blocks.

[0494] vii. The width / height of the current block.

[0495] viii. Slice type / picture type / slice group type.

[0496] ix. Color components.

[0497] x. Statistics of the segmentation type from the previous encoding and decoding blocks.

[0498] 19. Whether and / or how QUI-T is used may depend on the color format (such as 4:4:4 or 4:2:0) and / or color components.

[0499] a. Whether and how QUI-T is used may depend on whether the luma and chroma codec trees are separate.

[0500] b. In one example, when the luma and chroma codec trees are separate, QUI-T can only be applied to the luma component.

[0501] 20. The above method is also applicable to SnT, StT, OctT, and UQT.

[0502] The examples described above may be combined in the context of the method described below, eg, method 1300 , which may be implemented at a video decoder / encoder.

[0503] Figure 13 A flowchart of an exemplary method for video processing is shown. The method 1300 includes, at step 1310, determining, for a current video block, in response to at least one condition, whether a first partitioning mode is applicable to the current video block, wherein under the first partitioning mode, the current video block is divided into M sub-blocks, and M>4; and, at step 1320, performing a conversion of the current video block based on the determination.

[0504] Figure 14 A flowchart of an exemplary method for video processing is shown. The method 1400 includes: at step 1410, for a video block, determining, based on an indication, whether and / or how to apply a first partitioning mode to the video block, wherein the first partitioning mode divides the video block into M parts, where M>4; and performing a conversion of the video block based on the determination.

[0505] Some embodiments and techniques related to methods 1300 and 1400 may be described using the following examples.

[0506] In one example, a method for video processing is disclosed, including: determining, for a current video block, in response to at least one condition, whether a first partitioning mode is applicable to the current video block, wherein, in the first partitioning mode, the current video block is divided into M sub-blocks, and M>4; and performing conversion of the current video block based on the determination.

[0507] In one example, M=5, and the current video block is divided into five sub-blocks using a quinary tree (QUI-T) in a first partitioning mode.

[0508] In one example, the at least one condition depends on at least one of a maximum block size, a minimum block size, and a maximum depth allowed by the first partitioning mode.

[0509] In one example, the maximum depth includes at least one of a maximum bit depth and a maximum split depth.

[0510] In one example, at least one condition is determined from an indication signaled at a video unit level, where a video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

[0511] In one example, at least one condition is determined from an indication signaled in at least one of a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), an adaptation parameter set (APS), a sequence header, a picture header, a slice header, and a slice group header.

[0512] In one example, the at least one condition is derived from at least one of a depth of a multi-type tree (MTT) or a depth of a quadtree (QT).

[0513] In one example, the maximum block size is the size of a maximum codec block / unit or the size of a virtual pipeline data unit (VPDU).

[0514] In one example, the largest codec block / unit is a codec tree block / unit (CTB / CTU).

[0515] In one example, the at least one condition depends on at least one of a profile, a level, and a layer of a codec standard.

[0516] In one example, at least one of the maximum block size, the minimum block size, and the maximum depth is derived in the same manner as the QT partitioning mode.

[0517] In one example, the at least one condition depends on at least one of a slice group, a slice, a slice type, a color component, and activation of a dual tree.

[0518] In one example, the first partition mode has multiple partition patterns, through which one block can be divided into M sub-blocks in different ways, and at least one condition is different between different partition patterns.

[0519] In one example, all sub-blocks are leaf nodes, and the method further includes: dividing at least one sub-block into a plurality of parts, singly or recursively.

[0520] In one example, at least one sub-block is divided in at least one of the first partitioning mode, the QT partitioning mode, and the MTT partitioning mode.

[0521] In one example, the depth of at least one sub-block is adjusted based on the depth of the current video block.

[0522] In one example, the depth of the at least one sub-block is equal to the depth of the current video block plus one.

[0523] In one example, the depths of all sub-blocks are adjusted in the same manner, or the depths of different sub-blocks are adjusted in different manners.

[0524] In one example, the depth of the at least one sub-block is adjusted based on the size of the at least one sub-block.

[0525] In one example, at least one condition depends on the position of each sub-block.

[0526] In one example, if at least one sub-block crosses the boundary of a VPDU, the first partitioning mode is not applicable to the current video block.

[0527] In one example, the method further includes dividing any sub-block that crosses the boundary of the VPDU into multiple parts, either singly or recursively, until no part crosses the boundary of the VPDU.

[0528] In one example, at least one condition depends on the dimensions of the current video block.

[0529] In one example, the first partitioning mode is applicable to the current video block if the dimension of the current video block satisfies at least one of the following:

[0530] W>=T1;

[0531] H>=T2;

[0532] W×H>=T3;

[0533] Wherein, W and H represent the width and height of the current video block, respectively, and T1, T2 and T3 represent the first threshold to the third threshold, respectively.

[0534] In one example, the first partitioning mode is applicable to the current video block if the dimension of the current video block satisfies at least one of the following:

[0535] W<=T1';

[0536] H<=T2';

[0537] W×H<=T3';

[0538] Wherein, W and H represent the width and height of the current video block, respectively, and T1', T2' and T3' represent the first threshold to the third threshold, respectively.

[0539] In one example, the first partitioning mode is applied to the current video block in the horizontal direction if the dimension of the current video block satisfies at least one of the following:

[0540] H<=T4;

[0541] H>=T5;

[0542] Wherein, T4 and T5 represent the fourth threshold and the fifth threshold respectively.

[0543] In one example, T4=64 and T5=32.

[0544] In one example, the first partitioning mode is applied to the current video block in the vertical direction if the dimension of the current video block satisfies at least one of the following:

[0545] W<=T6;

[0546] W>=T7;

[0547] Wherein, T6 and T7 represent the sixth threshold and the seventh threshold, respectively.

[0548] In one example, T6=64 and T7=32.

[0549] In one example, the first partitioning mode is not applicable to the current video block in the horizontal direction if the dimension of the current video block satisfies at least one of the following:

[0550] H<=16;

[0551] H>=128.

[0552] In one example, the first partitioning mode is not applicable to the current video block in the vertical direction if the dimension of the current video block satisfies at least one of the following:

[0553] W<=16;

[0554] W>=128.

[0555] In one example, at least one condition depends on the partition depth of the current video block.

[0556] In one example, the first partitioning mode is applicable to the current video block if the partition depth of the current video block satisfies at least one of the following:

[0557] D<=D1;

[0558] D>=D2;

[0559] Where D, D1 and D2 represent the partition depth of the current video block, the first depth threshold and the second depth threshold respectively.

[0560] In one example, the partition depth of the current video block includes at least one of a QT partition depth, a binary tree (BT) partition depth, a ternary tree (TT) partition depth, an MTT partition depth, and a partition depth in the first partition mode.

[0561] In one example, at least one condition depends on the position of the current video block.

[0562] In one example, if the current video block crosses a boundary of at least one of a picture, a slice, and a slice group that includes the current video block, the first partitioning mode is not applicable to the current video block in at least one direction.

[0563] In one example, the border includes at least one of a bottom border and a right border.

[0564] In one example, the at least one direction includes a vertical direction, a horizontal direction, and a mixed direction including both the vertical direction and the horizontal direction.

[0565] In one example, the method further includes skipping, in subsequent conversions, any sub-blocks located outside of one of a picture, a slice, and a slice group that includes the current video block.

[0566] In one example, if any sub-block has a first portion and a second portion located outside and inside one of a picture, a slice, and a slice group, respectively, the method includes skipping the first portion in subsequent conversion.

[0567] In one example, the second portion is divided into a plurality of sub-portions.

[0568] In one example, the second portion is converted into codec units.

[0569] In one example, at least one of a width and a height of the second portion is equal to a power of two.

[0570] In one example, if any sub-block is partially or completely outside of at least one of a picture, a slice, and a slice group, the first partitioning mode is not applicable to the current video block.

[0571] In one example, the first partitioning mode is not applicable to the current video block if one of the following is satisfied:

[0572] At least one sub-block reaches the maximum depth allowed by the first partitioning mode;

[0573] At least one sub-block reaches the minimum block size allowed by the first partitioning mode;

[0574] At least one sub-block reaches a block size that can support transformation;

[0575] In one example, at least one threshold is signaled in a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), a picture header, a slice header, a slice group header, or a slice header.

[0576] In one example, at least one threshold is signaled in a video unit level, where a video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

[0577] In one example, the signaled at least one threshold is shared by the ternary tree (TT) partitioning and the first partitioning mode, or is shared by the binary tree (BT) partitioning and the first partitioning mode.

[0578] In one example, at least one threshold value depends on a sample component of the current video block.

[0579] In one example, the sample component includes at least one of a color component, a luma component, and a chroma component.

[0580] In one example, if the luma and chroma codec trees of the current video block are separate from each other, then at least one threshold value differs between the luma component and the chroma components.

[0581] In one example, at least one of the following partitioning modes is not applicable to at least one sub-block:

[0582] QT segmentation;

[0583] BT splitting in the horizontal direction;

[0584] BT splitting in the vertical direction;

[0585] TT split in the horizontal direction;

[0586] TT split in the vertical direction;

[0587] Asymmetric quadtree (UQT) partitioning in the horizontal direction;

[0588] UQT segmentation in the vertical direction; and

[0589] First split mode.

[0590] In one example, at least one condition depends on whether the current video block belongs to a leaf node to which no other partitioning mode is applicable.

[0591] In one example, the method further includes determining a first indication indicating whether the first partitioning mode is applicable to the leaf node.

[0592] In one example, the first segmentation mode has one or more segmentation patterns, and the method includes determining a second indication indicating which segmentation pattern to use.

[0593] In one example, the at least one condition depends on at least one of a color format, a luma component, and a chroma component.

[0594] In one example, if the luma and chroma codec trees of the current video block are separate from each other, the first partitioning mode is only applied to the luma component of the current video block.

[0595] In another aspect, a method for video processing is disclosed, comprising:

[0596] For the video block, determining, based on an indication, whether and / or how to apply a first partitioning mode to the video block, wherein the video block is divided into M parts under the first partitioning mode, M>4; and

[0597] Transitioning of the video block is performed based on the determination.

[0598] In one example, M=5, and the video block is divided into five parts using a quinary tree (QUI-T) in a first partitioning mode.

[0599] In one example, the first segmentation mode has one or more segmentation patterns.

[0600] In one example, the indication is signaled in a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), a sequence header, a picture header, a slice header, a slice group header, or a slice header.

[0601] In one example, the indication is signaled in a video unit level, where a video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

[0602] In one example, the indication is signaled in the bitstream representation of the video block.

[0603] In one example, multiple partitioning patterns are designed based on the shape or size of the video blocks.

[0604] In one example, a plurality of partitioning patterns are designed based on one of a picture, a slice, and a stripe having different temporal layers.

[0605] In one example, the indication depends on at least one of video resolution, picture resolution, codec mode, video content, slice type, picture type, slice group type, and a low delay check flag.

[0606] In one example, the video content includes at least one of screen content, a camera captured sequence, or mixed content.

[0607] In one example, the indication is represented by one or more syntax elements, wherein the one or more syntax elements include a first syntax element indicating whether partitioning is performed on the video block.

[0608] In one example, the one or more syntax elements further include a second syntax element indicating a partitioning tree and a partitioning direction to be used in the partitioning.

[0609] In one example, the indication is represented by one or more syntax elements, wherein the one or more syntax elements include a first syntax element indicating an index of a type of partition tree to be applied to the video block.

[0610] In one example, the type of the partition tree belongs to at least one of the following: BT, TT, QT, first partition, and non-partition.

[0611] In one example, the one or more syntax elements further include a second syntax element indicating at least one of a partition direction and a partition pattern.

[0612] In one example, the first syntax element is signaled only if the corresponding partition tree is valid for the video block.

[0613] In one example, the segmentation direction includes at least one of a vertical direction, a horizontal direction, and a mixed direction including both the vertical direction and the horizontal direction.

[0614] In one example, the second syntax element is signaled before or after the first syntax element.

[0615] In one example, the second syntax element is signaled only if the corresponding partition direction is valid for the video block.

[0616] In one example, the indication is represented as a binary codeword including a first bit to indicate whether the first partitioning mode is applied to the video block.

[0617] In one example, if the first bit indicates that the first partitioning mode is not applied, the binary codeword further includes a second bit to indicate whether BT or TT partitioning is applied to the video block.

[0618] In one example, if the first bit indicates that the first partitioning mode is applied, the binary codeword further includes one or more bits to indicate which partitioning pattern is applied to the video block.

[0619] In one example, the indication is represented as a binary codeword, where:

[0620] The binary codeword uses the first bit to indicate one of the BT and TT partitions;

[0621] The binary codeword uses the first bit and the second bit to indicate the other of the BT and TT partitions; and

[0622] The binary codeword uses a first bit, a second bit, and one or more subsequent bits to indicate which partition pattern of the first partition mode.

[0623] In one example, the indication is represented as a binary codeword, where:

[0624] The binary codeword uses the first bit to indicate the first segmentation mode;

[0625] The binary codeword uses the first and second bits to indicate BT and TT partitions.

[0626] In one example, the binary codeword is a truncated unary code.

[0627] In one example, the indication is signaled for one or more partitioning modes valid for the video block, and the one or more partitioning modes include at least one of BT, TT, and the first partitioning mode.

[0628] In one example, one or more segmentation patterns use only one segmentation direction that was previously signaled or derived.

[0629] In one example, no indication is signaled for any invalid partitioning mode for a video block or only one valid partitioning mode for a video block.

[0630] In one example, if there are only two partitioning modes valid for the video block, the indication includes a flag to indicate which partitioning mode was used for the video block.

[0631] In one example, if there are more than two partitioning modes valid for the video block, the indication includes a binary codeword to indicate which partitioning mode is used for the video block.

[0632] In one example, the binary codeword is a truncated unary code, and the truncated unary code has a maximum value equal to N-1, where N represents the number of partitioning modes valid for the video block.

[0633] In one example, if the first partitioning mode or at least one of the partitioning patterns is not valid for the video block, signaling of the at least one partitioning pattern is skipped or a flag of the signaling is constrained to be false.

[0634] In one example, if the first partitioning mode is applied to the video block, the indication also indicates which partitioning pattern is applied to the video block.

[0635] In one example, if the first partitioning mode has only one partitioning pattern valid for the video block, then that partitioning pattern is implicitly used without signaling.

[0636] In one example, if the first partitioning mode has two partitioning patterns valid for the video block, the indication includes a flag to indicate which partitioning pattern is used for the video block.

[0637] In one example, if the first partitioning mode has more than two partitioning patterns valid for the video block, the indication includes a binary codeword to indicate which partitioning pattern is used for the video block.

[0638] In one example, the binary codewords are encoded and decoded by arithmetic coding with at least one context or with a bypass mode.

[0639] In one example, some bits of a binary codeword are encoded or decoded using at least one context, and the remaining bits are encoded or decoded using a bypass mode.

[0640] In one example,

[0641] All bits of a binary codeword are encoded or decoded using at least one context; or

[0642] All bits of the binary codeword are encoded and decoded in bypass mode.

[0643] In one example, the at least one context depends on at least one of the following:

[0644] The position or index of a bit in a binary codeword;

[0645] a characteristic of at least one of a spatial neighboring block, a temporal neighboring block, and a video block;

[0646] Statistics of segmentation types from previous codec blocks;

[0647] a type of at least one of a slice, a picture, and a slice group covering the video block; and

[0648] Color components.

[0649] In one example, the characteristic of at least one of the spatial block, the temporal neighboring block, and the video block includes at least one of the following:

[0650] Split mode;

[0651] Split depth;

[0652] Codec mode;

[0653] width; and

[0654] high.

[0655] In one example, M=5, 6, 7, or 8.

[0656] In one example, the first partitioning mode includes an unsymmetric quadtree (UQT) partitioning.

[0657] In one example, the converting includes encoding the current video block into a bitstream representation of the video, and decoding the current video block from the bitstream representation of the video.

[0658] In one example, an apparatus in a video system is disclosed, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method of any of the above examples.

[0659] In one example, a computer program product stored on a non-transitory computer-readable medium is disclosed, the computer program product including program code for executing the method of any one of the above examples.

[0660] 5. Example Implementations of the Disclosed Technology

[0661] Figure 12 1 is a block diagram of a video processing device 1200. Apparatus 1200 may be used to implement one or more methods described herein. Apparatus 1200 may be embodied in a smartphone, tablet, computer, Internet of Things (IoT) receiver, etc. Apparatus 1200 may include one or more processors 1202, one or more memories 1204, and video processing hardware 1206. Processor(s) 1202 may be configured to implement one or more methods described in this document (including, but not limited to, method 1200). Memory(s) 1204 may be used to store data and code for implementing the methods and techniques described herein. Video processing hardware 1206 may be used to implement some of the techniques described in this document in hardware circuitry.

[0662] In some embodiments, the video encoding and decoding method can use the reference Figure 12 The method is implemented by the device implemented on the hardware platform.

[0663] It will be appreciated from the foregoing that specific embodiments of the disclosed technology have been described herein for illustrative purposes, but various modifications may be made without departing from the scope of the invention. Accordingly, the disclosed technology is not to be limited except by the appended claims.

[0664] Implementations of the subject matter and functional operations described in this patent document can be implemented in various systems, digital electronic circuits, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or in a combination of one or more of these. Implementations of the subject matter described in this specification can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a tangible and non-transitory computer-readable medium, for execution by a data processing apparatus or to control the operation of the data processing apparatus. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a combination of matter that implements a machine-readable propagated signal, or a combination of one or more of these. The term "data processing unit" or "data processing apparatus" encompasses all apparatus, devices, and machines for processing data, including, for example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the apparatus may also include code that creates an operating environment for the computer program in question, such as code constituting processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of these.

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

[0666] The processes and logic flows described in this specification can be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus can be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit).

[0667] For example, processors suitable for executing computer programs include general-purpose and special-purpose microprocessors, as well as any one or more processors of any type of digital computer. Typically, a processor will receive instructions and data from a read-only memory or a random access memory, or both. The basic elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, a computer will also include one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks, or be operatively coupled to receive data from or transfer data to one or more mass storage devices, or both. However, a computer does not necessarily require such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, for example, semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices. The processor and memory may be supplemented by or incorporated into dedicated logic circuitry.

[0668] This specification and drawings are to be regarded as exemplary only, where exemplary means example. As used herein, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. Furthermore, the use of "or" is intended to include "and / or" unless the context clearly indicates otherwise.

[0669] Although this patent document contains many details, these should not be construed as limitations on any invention or the scope of what is claimed, but rather as descriptions of features specific to particular embodiments of particular inventions. Certain features described in this patent document in the context of separate embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented in multiple embodiments, alone or in any suitable subcombination. Furthermore, although the features described above may be described as functioning in certain combinations, or even initially claimed as such, in some cases one or more features in the combination may be deleted from the claimed combination, and the claimed combination may be directed to a subcombination or a variation of the subcombination.

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

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

Claims

1. A video processing method, comprising: For a current video block, determining, in response to at least one condition, whether a first partitioning mode is applicable to the current video block, wherein in the first partitioning mode, the current video block is partitioned into M sub-blocks, M=5, and in the first partitioning mode, the current video block is partitioned into five sub-blocks using a quinary tree (QUI-T); and performing a conversion of the current video block based on the determination, If at least one sub-block crosses a boundary of a virtual pipeline data unit VPDU, the first segmentation mode is not applicable to the current video block.

2. The method according to claim 1, wherein The at least one condition depends on at least one of a maximum block size, a minimum block size, and a maximum depth allowed by the first partitioning mode.

3. The method according to claim 2, wherein: The maximum depth includes at least one of a maximum bit depth and a maximum split depth.

4. The method according to claim 1 or 2, wherein: The at least one condition is determined from an indication signaled at a video unit level, wherein a video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

5. The method according to claim 1 or 2, wherein: The at least one condition is determined from an indication signaled in at least one of a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), an adaptation parameter set (APS), a sequence header, a picture header, a slice header, and a slice group header.

6. The method according to claim 1 or 2, wherein: The at least one condition is derived from at least one of a depth of a multi-type tree (MTT) or a depth of a quadtree (QT).

7. The method according to claim 2, wherein: The maximum block size is the size of the maximum codec block / unit or the size of the VPDU.

8. The method according to claim 7, wherein: The largest codec block / unit is a codec tree block / unit (CTB / CTU).

9. The method according to claim 1 or 2, wherein: The at least one condition depends on at least one of a profile, a level, and a layer of a codec standard.

10. The method according to claim 2, wherein: At least one of the maximum block size, the minimum block size, and the maximum depth is derived in the same manner as the QT partitioning mode.

11. The method according to claim 1 or 2, wherein: The at least one condition depends on at least one of a slice group, a slice, a slice type, a color component, and activation of a dual tree.

12. The method according to claim 1 or 2, wherein: The first partition mode has a plurality of partition patterns, through which one block can be divided into M sub-blocks in different ways, and the at least one condition is different between different partition patterns.

13. The method according to claim 1 or 2, wherein: All child blocks are leaf nodes, and the method further comprises: At least one sub-block is divided into a plurality of parts singly or recursively.

14. The method according to claim 13, wherein The at least one sub-block is divided in at least one of a first partitioning mode, a QT partitioning mode, and an MTT partitioning mode.

15. The method according to claim 14, wherein The depth of the at least one sub-block is adjusted based on the depth of the current video block.

16. The method according to claim 15, wherein The depth of the at least one sub-block is equal to the depth of the current video block plus 1.

17. The method according to claim 13, wherein: Adjust the depth of all sub-blocks in the same way, or adjust the depth of different sub-blocks in different ways.

18. The method according to claim 13, wherein The depth of the at least one sub-block is adjusted based on the size of the at least one sub-block.

19. The method according to claim 1, wherein The at least one condition depends on the position of each sub-block.

20. The method of claim 19, further comprising: Any sub-block that crosses the boundary of the VPDU is divided into multiple parts, either singly or recursively, until no part crosses the boundary of the VPDU.

21. The method according to claim 1, wherein The at least one condition depends on a dimension of the current video block.

22. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is applicable to the current video block: W>=T1; H>=T2; W×H>=T3; Wherein, W and H represent the width and height of the current video block, respectively, and T1, T2 and T3 represent the first threshold to the third threshold, respectively.

23. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is applicable to the current video block: W<=T1'; H<=T2'; W×H<=T3'; Wherein, W and H represent the width and height of the current video block, respectively, and T1', T2' and T3' represent the first threshold to the third threshold, respectively.

24. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is applied to the current video block in the horizontal direction: H<=T4; H>=T5; Wherein, T4 and T5 represent the fourth threshold and the fifth threshold respectively.

25. The method according to claim 24, wherein T4=64 and T5=32.

26. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is applied to the current video block in the vertical direction: W<=T6; W>=T7; Wherein, T6 and T7 represent the sixth threshold and the seventh threshold, respectively.

27. The method according to claim 26, wherein T6=64 and T7=32.

28. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is not applicable to the current video block in the horizontal direction: H<＝16； H>＝128。 29. The method according to claim 21, wherein If the dimension of the current video block satisfies at least one of the following, the first partitioning mode is not applicable to the current video block in the vertical direction: W<＝16； W>＝128。 30. The method of claim 1, wherein The at least one condition depends on a partition depth of the current video block.

31. The method according to claim 30, wherein If the partition depth of the current video block satisfies at least one of the following, the first partition mode is applicable to the current video block: D<=D1; D>=D2; Where D, D1 and D2 represent the partition depth of the current video block, the first depth threshold and the second depth threshold respectively.

32. The method according to claim 31, wherein The partition depth of the current video block includes at least one of a QT partition depth, a binary tree (BT) partition depth, a ternary tree (TT) partition depth, an MTT partition depth, and a partition depth in a first partition mode.

33. The method of claim 1, wherein The at least one condition depends on a position of the current video block.

34. The method according to claim 33, wherein If the current video block crosses a boundary of at least one of a picture, a slice, and a slice group that includes the current video block, the first partitioning mode is not applicable to the current video block in at least one direction.

35. The method according to claim 34, wherein The border includes at least one of a bottom border and a right border.

36. The method according to claim 34 or 35, wherein The at least one direction includes a vertical direction, a horizontal direction, and a mixed direction including both the vertical direction and the horizontal direction.

37. The method of claim 33, further comprising: In subsequent conversions, any sub-blocks that are outside one of the pictures, slices, and slice groups that include the current video block are skipped.

38. The method of claim 33, wherein: If any sub-block has a first portion and a second portion located outside and inside one of a picture, a slice, and a slice group, respectively, the method includes skipping the first portion in a subsequent conversion.

39. The method according to claim 38, wherein The second portion is divided into a plurality of sub-portions.

40. The method of claim 38, wherein The second portion is converted into a codec unit.

41. The method according to claim 40, wherein At least one of a width and a height of the second portion is equal to a power of 2.

42. The method of claim 33, wherein: If any sub-block is partially or completely outside of at least one of a picture, a slice, and a slice group, the first partitioning mode is not applicable to the current video block.

43. The method of claim 2, wherein: The first segmentation mode is not applicable to the current video block if one of the following is satisfied: At least one sub-block reaches the maximum depth allowed by the first partitioning mode; At least one sub-block reaches the minimum block size allowed by the first partitioning mode; At least one sub-block reaches a block size capable of supporting transformation.

44. The method according to any one of claims 22 to 26 and 31, wherein At least one threshold is signaled in a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), a picture header, a slice header, a slice group header, or a slice header.

45. The method according to any one of claims 22 to 26 and 31, wherein At least one threshold is signaled at a video unit level, where a video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

46. The method of claim 44, wherein The signaled at least one threshold is common to the ternary tree (TT) partitioning and the first partitioning mode, or is common to the binary tree (BT) partitioning and the first partitioning mode.

47. The method according to any one of claims 22 to 26 and 31, wherein At least one threshold value depends on a sample component of the current video block.

48. The method of claim 47, wherein The sample component includes at least one of a color component, a brightness component, and a chrominance component.

49. The method according to claim 48, wherein If the luma and chroma codec trees of the current video block are separate from each other, at least one threshold value differs between the luma component and the chroma components.

50. The method according to claim 1 or 2, wherein At least one of the following partitioning modes is not applicable to at least one sub-block: QT segmentation; BT splitting in the horizontal direction; BT splitting in the vertical direction; TT split in the horizontal direction; TT split in the vertical direction; Asymmetric quadtree (UQT) partitioning in the horizontal direction; UQT segmentation in the vertical direction; and First split mode.

51. The method of claim 1, wherein The at least one condition depends on whether the current video block belongs to a leaf node to which no other partitioning mode is applicable.

52. The method of claim 51 , further comprising: A first indication is determined indicating whether a first partitioning mode is applicable to the leaf node.

53. The method of claim 52, wherein: The first segmentation mode has one or more segmentation patterns, and the method includes: A second indication indicating which partitioning pattern to use is determined.

54. The method of claim 1, wherein The at least one condition depends on at least one of a color format, a luma component, and a chroma component.

55. The method of claim 54, wherein If the luma and chroma codec trees of the current video block are separate from each other, the first partitioning mode is only applicable to the luma component of the current video block.

56. The method of claim 1, wherein The converting includes encoding the current video block into a bitstream of video.

57. The method of claim 1, wherein The converting includes decoding the current video block from a bitstream of the video.

58. A video processing method, comprising: For the video block, determining, based on the indication, whether and / or how to apply a first partitioning mode to the video block, wherein the video block is partitioned into M parts under the first partitioning mode, M=5, and the video block is partitioned into five sub-blocks using a quinary tree (QUI-T) under the first partitioning mode; and performing a conversion of the video block based on the determination, If at least one sub-block crosses a boundary of a virtual pipeline data unit (VPDU), the first segmentation mode is not applicable to the video block.

59. The method of claim 58, wherein The first segmentation mode has one or more segmentation patterns.

60. The method of claim 58, wherein The indication is signaled in a sequence parameter set (SPS), a video parameter set (VPS), a picture parameter set (PPS), a sequence header, a picture header, a slice header, a slice group header, or a slice header.

61. The method of claim 58, wherein The indication is signaled at a video unit level, where the video unit includes at least one of a sequence, a video, a picture, a slice, a slice group, a codec tree unit (CTU) row, or a CTU region.

62. The method of claim 58, wherein The indication is signaled in a bitstream of the video block.

63. The method of claim 58, wherein Multiple partitioning patterns are designed based on the shape or size of the video block.

64. The method of claim 58, wherein A plurality of partitioning patterns are designed based on one of pictures, slices, and strips having different temporal layers.

65. The method of claim 58, wherein The indication depends on at least one of a video resolution, a picture resolution, a codec mode, a video content, a slice type, a picture type, a slice group type, and a low delay check flag.

66. The method of claim 65, wherein The video content includes at least one of screen content, camera captured sequence, or mixed content.

67. The method according to any one of claims 58 to 66, wherein The indication is represented by one or more syntax elements, wherein the one or more syntax elements include a first syntax element indicating whether partitioning is performed on the video block.

68. The method of claim 67, wherein The one or more syntax elements also include a second syntax element indicating a partitioning tree and a partitioning direction to be used in the partitioning.

69. The method according to any one of claims 58 to 66, wherein The indication is represented by one or more syntax elements, wherein the one or more syntax elements include a first syntax element indicating an index of a type of partition tree to be applied to the video block.

70. The method of claim 69, wherein The type of the partition tree belongs to at least one of the following: BT, TT, QT, first partition and non-partition.

71. The method of claim 69, wherein The one or more syntax elements further include a second syntax element indicating at least one of a partition direction and a partition pattern.

72. The method of claim 69, wherein The first syntax element is signaled only if the corresponding partition tree is valid for the video block.

73. The method of claim 68, wherein The division direction includes at least one of a vertical direction, a horizontal direction, and a mixed direction including both the vertical direction and the horizontal direction.

74. The method of claim 68, wherein The second syntax element is signaled before or after the first syntax element.

75. The method of claim 68, wherein The second syntax element is signaled only if the corresponding partition direction is valid for the video block.

76. The method of any one of claims 58-66, wherein: The indication is represented as a binary codeword including a first bit to indicate whether a first partitioning mode is applied to the video block.

77. The method of claim 76, wherein If the first bit indicates that the first partitioning mode is not applied, the binary codeword also includes a second bit to indicate whether BT or TT partitioning is applied to the video block.

78. The method of claim 76, wherein If the first bit indicates application of the first partitioning mode, the binary codeword further includes one or more bits for indicating which partitioning pattern is applied to the video block.

79. The method according to any one of claims 58 to 66, wherein The indication is represented as a binary codeword, where The binary codeword uses the first bit to indicate one of BT and TT partitions; The binary codeword uses the first bit and the second bit to indicate the other of the BT and TT partitions; and The binary codeword uses a first bit, a second bit, and one or more subsequent bits to indicate which partition pattern of the first partition mode.

80. The method according to any one of claims 58 to 66, wherein The indication is represented as a binary codeword, where The binary codeword uses the first bit to indicate the first segmentation mode; The binary codeword uses the first bit and the second bit to indicate BT and TT partitions.

81. The method of claim 76, wherein The binary codeword is a truncated unary code.

82. The method according to any one of claims 60 to 62, wherein The indication is signaled for one or more partitioning modes valid for the video block, and the one or more partitioning modes include at least one of BT, TT, and the first partitioning mode.

83. The method of claim 82, wherein The one or more segmentation patterns use only one segmentation direction previously signaled or derived.

84. The method according to any one of claims 60 to 62, wherein For any partitioning mode that is invalid for the video block or for only one valid partitioning mode for the video block, no indication is signaled.

85. The method of claim 82, wherein If there are only two partitioning modes valid for the video block, the indication includes a flag indicating which partitioning mode is used for the video block.

86. The method of claim 82, wherein If there are more than two partitioning modes valid for the video block, the indication includes a binary codeword to indicate which partitioning mode was used for the video block.

87. The method of claim 86, wherein The binary codeword is a truncated unary code, and the truncated unary code has a maximum value equal to N-1, where N represents the number of partitioning modes valid for the video block.

88. The method of claim 82, wherein If the first partitioning mode or at least one of the first partitioning modes is invalid for the video block, signaling of the at least one partitioning pattern is skipped or a flag of the signaling is constrained to be false.

89. The method of claim 82, wherein If the first partitioning mode is applied to the video block, the indication also indicates which partitioning pattern is applied to the video block.

90. The method of claim 89, wherein If the first partitioning mode has only one partitioning pattern valid for the video block, that partitioning pattern is used implicitly without signaling.

91. The method of claim 89, wherein If the first partitioning mode has two partitioning patterns valid for the video block, the indication includes a flag to indicate which partitioning pattern is used for the video block.

92. The method of claim 89, wherein If the first partitioning mode has more than two partitioning patterns valid for the video block, the indication includes a binary codeword to indicate which partitioning pattern is used for the video block.

93. The method of claim 76, wherein: The binary codeword is encoded and decoded by arithmetic coding and decoding with at least one context or with a bypass mode.

94. The method of claim 93, wherein Part of the bits of the binary codeword are encoded and decoded using at least one context, and the remaining bits are encoded and decoded using a bypass mode.

95. The method of claim 93, wherein All bits of the binary codeword are encoded or decoded using at least one context; or All bits of the binary codeword are encoded and decoded using the bypass mode.

96. The method of claim 93, wherein The at least one context depends on at least one of the following: the position or index of a bit in the binary codeword; a characteristic of at least one of a spatial neighboring block, a temporal neighboring block, and a video block; Statistics of segmentation types from previous codec blocks; a type of at least one of a slice, a picture, and a slice group covering the video block; as well as Color components.

97. The method of claim 96, wherein The characteristics of at least one of the spatial block, the temporal neighboring block, and the video block include at least one of the following: Split mode; Depth of division; Codec mode; width; and high.

98. The method of claim 58, wherein The converting includes encoding the video blocks into a bitstream of video.

99. The method of claim 58, wherein The converting includes decoding the video blocks from a bitstream of the video.

100. An apparatus in a video system, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method of any one of claims 1 to 99.

101. A non-transitory computer-readable medium storing program instructions, which, when executed by a computer, implement the method according to any one of claims 1 to 99.

Images