Video block partitioning based on quinary tree

Abstract

The present application relates to a video processing method, device and system, wherein a representative method comprises: determining, according to division information, a partition mode of dividing a current video block into M parts for the current video block of a video, wherein M>4; and performing conversion of the current video block based on the partition mode.

Description

[0001] Cross-references to related applications

[0002] This application is an application filed on February 11, 2020, under International Patent Application No. PCT / CN2020 / 074745, which entered the Chinese national phase. The entire disclosure of that application is incorporated herein by reference. Technical Field

[0003] This patent document relates to video encoding and decoding technologies, devices, and systems. Background Technology

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

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

[0006] In one representative aspect, a method for video processing is disclosed, comprising: determining a segmentation pattern for dividing the current video block into M parts, where M>4, based on segmentation information; and performing a transformation of the current video block based on the segmentation pattern.

[0007] In another representative aspect, a method for video processing is disclosed, comprising: determining whether it is permissible to divide the current video block into five sub-blocks by quinary-tree (QUI-T) segmentation based on whether the current video meets certain conditions; and performing a transformation of the current video block based on the determination.

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

[0009] In another representative aspect, an apparatus configured or operable to perform the above-described methods is disclosed. The apparatus may include a processor programmed to implement the methods.

[0010] In another representative aspect, video decoder devices can implement the methods described in this paper.

[0011] The above and other aspects and features of the disclosed technology are described in more detail in the accompanying drawings, description and claims. Attached Figure Description

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

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

[0014] Figure 3A and Figure 3B Examples of segmented code tree blocks (CTBs) and their corresponding quadtrees are shown.

[0015] Figure 4 An example of a quadtree plus binary tree (QTBT) is shown.

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

[0017] Figures 6A-6E An example of a permissible split is shown between the parent split (solid line) and the current split (dashed line), where “X” indicates a permissible split.

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

[0019] Figure 8 An example of a signaling structure with QTBT and EQT splitting is shown.

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

[0021] Figures 10A-10E An example of penttree (QUI-T) partitioning is shown.

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

[0023] Figure 12 This is a block diagram illustrating an example of an apparatus that can implement a video encoder and / or decoder, which can be used to implement various parts of the technology disclosed herein.

[0024] Figure 13 A flowchart illustrating an example method for video processing based on the disclosed techniques is shown.

[0025] Figure 14 A flowchart is shown for another example method for video processing based on the disclosed techniques. Detailed Implementation

[0026] Due to the ever-increasing demand for higher resolution video, video encoding and decoding methods and technologies are ubiquitous in modern technology. Video codecs typically consist of electronic circuitry or software that compresses or decompresses digital video and are constantly being improved to provide higher encoding and decoding efficiency. Video codecs convert uncompressed video into 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 latency (delay). Compression formats typically conform to standard video compression specifications, such as the High Efficiency Video Codec (HEVC) standard (also known as H.265 or MPEG-H Part 2), the upcoming Universal Video Codec (VVC) standard, or other current and / or future video codec standards.

[0027] Embodiments of the disclosed techniques 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 readability and do not in any way limit the discussion or embodiments (and / or implementations) to the relevant section only.

[0028] 1. Overview of Video Codec Standards

[0029] Video codec standards have primarily evolved from well-known ITU-T and ISO / IEC standards. ITU-T developed H.261 and H.263, while ISO / IEC developed MPEG-1 and MPEG-4 Vision. These two organizations jointly developed the H.262 / MPEG-2 Video and 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 architecture, using 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 incorporated them into reference software called the Joint Exploration Model (JEM). In April 2018, the Joint Video Experts Group (JVET) between VCEG (Q6 / 16) and ISO / IEC JTC1 SC29 / WG11 (MPEG) was established to work on the Multi-Functional Video Coding (VVC) standard, with the goal of reducing the bit rate by 50% compared to HEVC.

[0030] 2. Exemplary Example of Pentree Partitioning

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

[0032] The terminology used in H.264 / AVS is macroblock and MB mode / 8×8 mode (segmentation). A macroblock is a unit in which each picture / strip is divided and intra / inter mode determination is applied. A segmentation 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 luma sample block and, in the typical case of 4:2:0 color sampling, two corresponding 8×8 chroma sample blocks.

[0034] 2.1.1 H.264 / AVC main profile

[0035] Intra-frame codec blocks use spatial prediction to leverage spatial correlations within pixels. Two partitioning schemes are defined: 16×16 and 4×4.

[0036] Inter-frame codec blocks use temporal prediction instead of spatial prediction to estimate motion in the image. Motion can be estimated independently for a 16×16 macroblock or any of its sub-macroblocks (16×8, 8×16, 8×8). Syntax elements (MB modes) are signaled to indicate whether 16×16, 16×8, 8×16, or 8×8 is selected. If 8×8 is selected, further signaling is given to another syntax element (8×8 mode) to indicate whether 8×8, 8×4, 4×8, or 4×4 is used (see, for example, see...). Figure 1 Only one motion vector (MV) is allowed per segment.

[0037] 2.1.2 H.264 / AVC High-End

[0038] In higher resolutions, 8×8 transform and I_8×8 (8×8 intra-frame prediction) are introduced. For macroblocks encoded and decoded intra-frame, 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 in inter-frame encoding / decoding, either a 4×4 or 8×8 transform can be selected. However, the transform size cannot exceed the segmentation size. For example, if a macroblock selects an 8×8 segmentation and further selects an 8×4 sub-mode, only a 4×4 transform can be applied. If a macroblock selects a 16×16, 16×8, 8×16, or 8×8 segmentation with 8×8 sub-modes, then either a 4×4 or 8×8 transform can be selected.

[0040] 2.1.3 Summary

[0041] Mode selection is determined at the macroblock level. The transform size must not exceed the segment size.

[0042] 2.2 Segmentation Tree Structure in HEVC

[0043] In HEVC, a coding tree unit (CTU) (also known as a maximum coding tree unit, LCU) is divided into coding units (CUs) using a quadtree structure represented as a codec tree to accommodate various local characteristics. The determination of whether to use inter-frame picture (temporal domain) or intra-frame picture (spatial domain) prediction to encode and decode picture regions is performed at the CU level. Each CU can be further divided into one, two, or four PUs based on the prediction unit (PU) partitioning 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 a prediction process based on the PU partitioning type, the CU can be partitioned into transform units (TUs) 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] The various features involved in hybrid video encoding and decoding using HEVC are described below.

[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 selected by the encoder and can be larger than a traditional macroblock. A CTU consists of a luma CTB, a corresponding chroma CTB, and syntax elements. The size L×L of the luma CTB can be selected as L = 16, 32, or 64 samples, with larger sizes generally achieving better compression. HEVC supports using a tree structure and quadtree-like signaling to divide the CTB into smaller blocks.

[0046] 2) Codec Unit (CU) and Codec Block (CB): The quadtree syntax of the CTU specifies the size and location 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 division of the CTU into luma CBs and chroma CBs is notified by joint signaling. One luma CB and usually two chroma CBs together with the associated syntax form a codec unit (CU). A CTB may contain only one CU or may be divided to form multiple CUs, and each CU has a tree of associated partitions and transform units (TUs) partitioned into prediction units (PUs).

[0047] 3) Prediction Units and Prediction Blocks (PBs): The determination of whether to use inter-frame or intra-frame prediction to encode and decode image regions is performed at the CU level. The root of the PU segmentation structure is at the CU level. Based on the basic prediction type, the luma CB and chroma CB can then be further subdivided in size and predicted according to the luma and chroma prediction blocks (PBs). HEVC supports variable PB sizes from 64×64 to 4×4 samples. Figure 2 The allowed PBs are described.

[0048] 4) Transform Units (TUs) and Transform Blocks: Prediction residuals are encoded and decoded using block transforms. The root of the TU tree structure is at the CU level. Luminance CB residuals can be the same as the Luminance Transform Blocks (TBs), or they can be further divided into smaller luminance TBs. The same applies to chrominance TBs. Integer basis functions similar to the Discrete Cosine Transform (DCT) are defined for square TB sizes of 4×4, 8×8, 16×16, and 32×32. For the 4×4 transform of the luminance intra-frame image prediction residuals, integer transforms derived from the form of the Discrete Sine Transform (DST) are alternately specified.

[0049] 2.2.1 Depth of a quadtree

[0050] For a given luma CB of size M×M, a flag signaling indicates whether it is divided into four blocks of size M / 2×M / 2. If further partitioning is possible, as indicated by the maximum depth signaling of the residual quadtree in the SPS (Sequence Parameter Set), a flag indicating whether it is divided into four quadrants is assigned to each quadrant. Leaf node blocks generated by the residual quadtree are transform blocks that are further processed by transform encoding and decoding. The encoder indicates the maximum and minimum luma TB sizes it will use. Partitioning is implicit when the CB size is greater than the maximum TB size. No partitioning is implicit when partitioning would result in a luma TB size less than the indicated minimum. 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 four 4×4 luma TBs), the chroma TB size is half the luma TB size in each dimension. In the case of CU for intra-frame picture prediction, the decoded samples of the nearest neighboring TB (inside or outside the CB) are used as reference data for intra-frame picture prediction.

[0051] 2.2.2 Summary

[0052] A CTU can be recursively partitioned into multiple CUs based on the increasing depth of the quadtree (e.g., Figure 3B Specify only the CB and TB partitions of the square, where the block can be recursively divided into quarters, such as... Figure 3A As shown.

[0053] Mode selection is determined at the CU level. Side information based on the selected mode is communicated via PU-level signaling, such as motion information and intra-frame prediction mode. Residuals are communicated via TU-level signaling.

[0054] For inter-frame codec blocks, a PU must not be greater than a CU, and for intra-frame codec blocks, a PU should be equal to a CU.

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

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

[0057] To explore future video coding and decoding 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 incorporated them into reference software called the Joint Exploration Model (JEM).

[0058] 2.3.1 QTBT Block Segmentation Structure

[0059] Unlike HEVC, the QTBT structure removes the separation of CU, PU, ​​and TU concepts and supports greater flexibility in CU segmentation shapes. In the QTBT block structure, CUs can have square or rectangular shapes. In the example, codec tree units (CTUs) are first segmented using a quadtree structure. The leaf nodes of the quadtree are further segmented using a binary tree structure. There are two types of partitioning in the binary tree: symmetrical horizontal partitioning and symmetrical vertical partitioning. The leaf nodes of the binary tree are called codec units (CUs), and this segmentation is used for prediction and transform processing without any further segmentation. This means that CUs, PUs, and TUs have the same block size in the QTBT codec block structure. In JEM, CUs sometimes consist of codec blocks (CBs) with different color components; for example, a CU in the case of P-strips and B-strips in a 4:2:0 chroma format contains one luma CB and two chroma CBs. Sometimes they consist of CBs with a single component; for example, a CU in the case of I-strips contains only one luma CB or only two chroma CBs.

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

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

[0062] –MinQTSize: Minimum allowed size of quadtree leaf nodes

[0063] –MaxBTSize: The maximum allowed size of the root node of the binary tree.

[0064] –MaxBTDepth: Maximum allowed binary tree depth

[0065] –MinBTSize: Minimum allowed size of binary leaf nodes

[0066] In one example of a QTBT segmentation structure, the CTU size is set to 128×128 luminance 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 segmentation is first applied to the CTU to generate quadtree leaf nodes. Quadtree leaf nodes can have sizes ranging from 16×16 (i.e., MinQTSize) to 128×128 (i.e., CTU size). If a quadtree leaf node is 128×128, it will not be further segmented by the binary tree because its size exceeds MaxBTSize (i.e., 64×64). Otherwise, the quadtree leaf node can be further segmented by 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 segmentation is not considered. When a binary tree node has a width equal to MinBTSize (i.e., 4), further horizontal partitioning is not considered. Similarly, when a binary tree node has a height equal to MinBTSize, further vertical partitioning is not considered. Leaf nodes of the binary tree are further processed through prediction and transformation without any further segmentation. In JEM, the maximum CTU size is 256×256 luminance samples.

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

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

[0069] In HEVC, inter-frame prediction for small blocks is restricted to reduce memory accesses for motion compensation, resulting in no bidirectional prediction for 4×8 and 8×4 blocks, and no inter-frame prediction for 4×4 blocks. These restrictions are removed in JEM's QTBT.

[0070] 2.3.2 QTBT Summary

[0071] A CTU can be recursively divided into multiple CUs based on the increasing depth of a quadtree or binary tree. Specify squares and rectangles CB (width / height equal to 1 / 2 or 2).

[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 Proposal in JVET-D0117

[0075] Support for tree types other than quadtrees and binary trees is proposed. In this implementation, two additional ternary tree (TT) partitions are introduced: a horizontal and a vertical center-side ternary tree, such as... Figure 5E and Figure 5F As shown.

[0076] In some embodiments, a segment of BT / TT can be further divided using BT / TT. Therefore, rectangular blocks are permitted.

[0077] It supports a two-level tree: a region tree (quadtree) and a prediction tree (binary or ternary). The CTU is first segmented using the region tree (RT). The RT leaves can be further subdivided using the prediction tree (PT). The PT leaves can also be further subdivided using the PT until the maximum PT depth is reached. The PT leaf is the basic encoding / decoding unit. For convenience, it is still referred to as the CU. The CU cannot be further subdivided. Prediction and transformation are applied to the CU in the same way as JEM. The entire segmentation structure is named a "multi-type tree".

[0078] 2.4.2 Split Tree in VVC

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

[0080] In VVC, signaling notifies / derives several variables to control the use of different segments. For example:

[0081] The maximum multi-type tree depth maxMttDepth with offsets for luminance and chrominance respectively.

[0082] Maximum binary tree size maxBtSize / Maximum ternary tree size maxTtSize

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

[0084] 7.3.2.1 Sequence Parameter Set (RBSP) Syntax

[0085]

[0086] Semantics

[0087] `sps_max_mtt_hierarchy_depth_inter_tile_groups` specifies the default maximum hierarchical depth of the codec units generated by multi-type quadtree partitioning in a tile group of the reference 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 hierarchical depth can be overridden by `tile_group_max_mtt_hierarchy_depth_luma` present in the tile group header of the reference SPS.

[0088] The value of sps_max_mtt_hierarchy_depth_inter_tile_groups should be within the range of 0 to CtbLog2SizeY - MinCbLog2SizeY (inclusive of endpoints).

[0089] `sps_max_mtt_hierarchy_depth_intra_tile_groups_luma` specifies the default maximum hierarchical depth of the codec units generated by multi-type quadtree partitioning in a tile group of the reference 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 tile group header of the reference SPS.

[0090] The value of sps_max_mtt_hierarchy_depth_intra_tile_groups_luma should be within the range of 0 to CtbLog2SizeY - MinCbLog2SizeY (inclusive of endpoints).

[0091] `sps_log2_diff_max_bt_min_qt_intra_tile_group_luma` specifies the default difference between the maximum size (width or height) of the luminance samples in the luminance codec blocks that can be partitioned using binary partitioning in a tile group of the reference SPS with `tile_group_type` equal to 2(I), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in the luminance leaf blocks generated by 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 tile group header of the reference SPS.

[0092] The value of sps_log2_diff_max_bt_min_qt_intra_tile_group_luma should be within the range of 0 to CtbLog2SizeY - MinQtLog2SizeIntraY (inclusive). When sps_log2_diff_max_bt_min_qt_intra_tile_group_luma does not exist,

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

[0094] `sps_log2_diff_max_tt_min_qt_intra_tile_group_luma` specifies the default difference between the maximum size (width or height) of the luminance samples in the luminance codec blocks that can be partitioned using ternary partitioning in a tile group of the reference SPS with `tile_group_type` equal to 2(I), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in the luminance leaf blocks generated by 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 tile group header of the reference SPS.

[0095] The value of sps_log2_diff_max_tt_min_qt_intra_tile_group_luma should be within the range of 0 to CtbLog2SizeY - MinQtLog2SizeIntraY (inclusive). When sps_log2_diff_max_tt_min_qt_intra_tile_group_luma does not exist,

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

[0097] `sps_log2_diff_max_bt_min_qt_inter_tile_group` specifies the default difference between the maximum size (width or height) of the luminance samples in the luminance codec blocks that can be partitioned using binary partitioning in a tile group of the reference SPS whose `tile_group_type` is equal to 0 (B) or 1 (P), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in the luminance leaf blocks generated by 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 tile group header of the reference SPS.

[0098] The value of sps_log2_diff_max_bt_min_qt_inter_tile_group should be within the range of 0 to CtbLog2SizeY - MinQtLog2SizeInterY (inclusive). When sps_log2_diff_max_bt_min_qt_inter_tile_group does not exist,

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

[0100] `sps_log2_diff_max_tt_min_qt_inter_tile_group` specifies the default difference between the maximum size (width or height) of the luminance samples in the luminance codec blocks that can be partitioned using ternary partitioning in a tile group of the reference SPS whose `tile_group_type` is equal to 0 (B) or 1 (P), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in the luminance leaf blocks generated by 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 tile group header of the reference SPS.

[0101] The value of sps_log2_diff_max_tt_min_qt_inter_tile_group should be within the range of 0 to CtbLog2SizeY - MinQtLog2SizeInterY (inclusive). When sps_log2_diff_max_tt_min_qt_inter_tile_group does not exist, its value is inferred to be equal to 0.

[0102] `sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma` specifies the default difference between the logarithm of the smallest size of the luminance samples in the chroma leaf blocks generated by the quadtree partitioning of the chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA` in a tile group of the reference SPS with `tile_group_type` equal to 2(I), and the logarithm of the smallest decoder block size in the luminance samples of the chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA`. When `partition_constraints_override_flag` equals 1, the default difference can be overridden by `tile_group_log2_diff_min_qt_min_cb_chroma` present in the tile group header of the reference SPS. The value of sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma should be within the range of 0 to CtbLog2SizeY - MinCbLog2SizeY (inclusive). When it does not exist, 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 the luminance samples of the chroma leaf blocks generated by the quadtree partitioning of a CTU with treeType equal to DUAL_TREE_CHROMA is derived as follows:

[0103] MinQtLog2SizeIntraC=sps_log2_diff_min_qt_min_cb_intra_tile_group_chroma+MinCbLog2SizeY (728)

[0104] `sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma` specifies the default maximum hierarchical depth of chroma codec units generated by multi-type tree partitioning of chroma quadtree leaves with a `treeType` of `DUAL_TREE_CHROMA` in a tile group of the reference 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_chroma` present in the tile group header of the reference SPS. The value of `sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). If it does not exist, the value of `sps_max_mtt_hierarchy_depth_intra_tile_groups_chroma` is inferred to be equal to 0.

[0105] `sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma` specifies the default difference between the maximum size (width or height) of the luminance samples in a chroma codec block that can be partitioned using binary partitioning within a tile group of the reference SPS whose `tile_group_type` is equal to 2(I), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in a chroma leaf block 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 tile group header of the reference SPS. The value of `sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma` should be in the range of 0 to `CtbLog2SizeY-MinQtLog2SizeIntraC` (inclusive). When sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma does not exist, the value of sps_log2_diff_max_bt_min_qt_intra_tile_group_chroma is inferred to be equal to 0.

[0106] `sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma` specifies the default difference between the maximum size (width or height) of the luminance samples in a chroma codec block that can be partitioned using ternary partitioning within a tile group of the reference SPS whose `tile_group_type` is equal to 2(I), and the base-2 logarithm of the minimum size (width or height) of the luminance samples in a chroma leaf block 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_tt_min_qt_chroma` present in the tile group header of the reference SPS. The value of `sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma` should be in the range of 0 to `CtbLog2SizeY-MinQtLog2SizeIntraC` (inclusive). When sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma does not exist, the value of sps_log2_diff_max_tt_min_qt_intra_tile_group_chroma is inferred to be equal to 0.

[0107] 2.4.2.1 Usage limitations of BT and TT

[0108] 2.4.2.1.1 Variable Definition

[0109] `tile_group_log2_diff_min_qt_min_cb_luma` specifies the base-2 logarithm of the smallest size of the luminance samples in the luminance leaf blocks generated by the quadtree partitioning of the CTU in the current tile group, and the base-2 logarithm of the smallest decoder block size in the luminance samples of the luminance 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 it does not exist, the value of `tile_group_log2_diff_min_qt_min_cb_luma` is inferred as follows:

[0110] -If tile_group_type equals 2(I), then

[0111] 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;

[0112] Otherwise (if tile_group_type equals 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.

[0113] `tile_group_max_mtt_hierarchy_depth_luma` specifies the maximum hierarchical depth of the codec unit generated by the multi-type tree partitioning of quadtree leaves in the current tile group. The value of `tile_group_max_mtt_hierarchy_depth_luma` should be within the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, the value of `tile_group_max_mtt_hierarchy_depth_luma` is inferred as follows:

[0114] - If tile_group_type equals 2(I), then 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;

[0115] Otherwise (if tile_group_type equals 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.

[0116] `tile_group_log2_diff_max_bt_min_qt_luma` specifies the base-2 logarithm between the maximum size (width or height) of the luminance samples in the luminance codec block that can be partitioned using binary partitioning within the current tile group and the minimum size (width or height) of the luminance samples in the luminance leaf block generated by the quadtree partitioning of the CTU. The value of `tile_group_log2_diff_max_bt_min_qt_luma` should be within the range of 0 to `CtbLog2SizeY - MinQtLog2SizeY` (inclusive). When it does not exist, the value of `tile_group_log2_diff_max_bt_min_qt_luma` is inferred as follows:

[0117] - If tile_group_type equals 2(I), 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;

[0118] Otherwise (if tile_group_type equals 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.

[0119] `tile_group_log2_diff_max_tt_min_qt_luma` specifies the base-2 logarithm between the maximum size (width or height) of the luma sample points of the luma codec block that can be partitioned using ternary partitioning in the current tile group and the minimum size (width or height) of the luma sample points of the luma leaf block generated by the quadtree partitioning of the CTU. The value of `tile_group_log2_diff_max_tt_min_qt_luma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeY` (inclusive). When it does not exist, the value of `tile_group_log2_diff_max_tt_min_qt_luma` is inferred as follows:

[0120] - If tile_group_type equals 2(I), 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;

[0121] Otherwise (if tile_group_type equals 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.

[0122] `tile_group_log2_diff_min_qt_min_cb_chroma` specifies the base-2 logarithm of the smallest size of the luminance samples in the chrominance leaf blocks generated by partitioning the chrominance CTU with `treeType` equal to `DUAL_TREE_CHROMA` in the current tile group, and the base-2 logarithm of the smallest decoder block size in the luminance samples of the chrominance CU with `treeType` equal to `DUAL_TREE_CHROMA`. The value of `tile_group_log2_diff_min_qt_min_cb_chroma` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, 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`.

[0123] `tile_group_max_mtt_hierarchy_depth_chroma` specifies the maximum hierarchical depth of the codec unit in the current tile group, resulting from the multi-type tree partitioning of quad-leaf trees with `treeType` equal to `DUAL_TREE_CHROMA`. The value of `tile_group_max_mtt_hierarchy_depth_chroma` should be in the range of 0 to `CtbLog2SizeY - MinCbLog2SizeY` (inclusive). When it does not exist, 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`.

[0124] `tile_group_log2_diff_max_bt_min_qt_chroma` specifies the base-2 logarithm between the maximum size (width or height) of the luminance samples in the chroma codec block that can be partitioned using binary partitioning within the current tile group and the minimum size (width or height) of the luminance samples in the chroma leaf block resulting from the quadtree partitioning of the chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA`. The value of `tile_group_log2_diff_max_bt_min_qt_chroma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeC` (inclusive). When it does not exist, 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`.

[0125] `tile_group_log2_diff_max_tt_min_qt_chroma` specifies the base-2 logarithm between the maximum size (width or height) of the luminance samples in the chroma codec block that can be partitioned using ternary partitioning within the current tile group and the minimum size (width or height) of the luminance samples in the chroma leaf block resulting from the quadtree partitioning of the chroma CTU with `treeType` equal to `DUAL_TREE_CHROMA`. The value of `tile_group_log2_diff_max_tt_min_qt_chroma` should be in the range of 0 to `CtbLog2SizeY - MinQtLog2SizeC` (inclusive). When it does not exist, 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`.

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

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

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

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

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

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

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

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

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

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

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

[0137] MaxMttDepthY=tile_group_max_mtt_hierarchy_depth_luma (7-43)

[0138] MaxMttDepthC=tile_group_max_mtt_hierarchy_depth_chroma (7-44)

[0139] log2_ctu_size_minus2 and log2_min_luma_coding_block_size_minus2 are notified by signaling in SPS.

[0140] The increment of 2 in log2_ctu_size_minus2 specifies the size of the luminance codec tree block for each CTU.

[0141] log2_min_luma_coding_block_size_minus2 plus 2 specifies the minimum luma encoding / decoding block size.

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

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

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

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

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

[0147] MinTbLog2SizeY=2 (7-11)

[0148] MaxTbLog2SizeY=6 (7-12)

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

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

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

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

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

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

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

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

[0157] PicSizeInSamplesY=pic_width_in_luma_samples*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 transformation size (64×64 luminance samples and corresponding chrominance samples) and the minimum transformation size (4×4 luminance samples and corresponding chrominance samples) are fixed and require further standardization and development.]

[0161] 2.4.2.1.2 Permissible Binary Partitioning Processes

[0162] The input to this process is:

[0163] -Binary partitioning mode btSplit,

[0164] - Encoder / decoder block width cbWidth

[0165] - Encoder block height cbHeight

[0166] - The position (x0, y0) of the top-left luminance sample point of the considered codec block relative to the top-left luminance sample point of the image.

[0167] -Multi-type tree depth mttDepth,

[0168] -MaximumMttDepth, the maximum multi-type tree depth 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 to FALSE if one or more of the following conditions are true:

[0177] / / Based on block size and 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, allowBtSplit is set to equal FALSE if all of the following conditions are true.

[0183] / / Based on image boundaries (the bottom image boundary and the bottom right image boundary are not perpendicular to each other)

[0184] -btSplit equals Split_BT_VER

[0185] -y0+cbHeight is greater than pic_height_in_luma_samples

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

[0187] / / Based on image boundaries (the right image boundary does not have a horizontal BT).

[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, allowBtSplit is set to FALSE if all of the following conditions are true:

[0192] / / Based on the TT segmentation at the previous level (mttDepth-1)

[0193] -mttDepth is greater than 0

[0194] -partIdx equals 1

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

[0196] / / Based on the transformation size (e.g., when MaxTbSizeY equals 64, for 64×128, there is no vertical BT; for 128×64, there is no horizontal BT)

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

[0198] -btSplit equals Split_BT_VER

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

[0200] -cbHeight is greater than MaxTbSizeY

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

[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 to TRUE.

[0206] 2.4.2.1.3 Permissible ternary partitioning processes

[0207] The input to this process is:

[0208] - Ternary partitioning mode ttSplit,

[0209] - Encoder / decoder block width cbWidth

[0210] - Encoder block height cbHeight

[0211] - The position (x0, y0) of the top-left luminance sample point of the considered codec block relative to the top-left luminance sample point of the image.

[0212] -Multi-type tree depth mttDepth

[0213] -MaximumMttDepth, the maximum multi-type tree depth with offset.

[0214] -Maximum binary tree size maxTtSize.

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

[0216] Table 2: Specifications 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 block 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] / / Based on the maximum allowed MTT depth

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

[0226] / / Based on whether it is located at the image boundary

[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 to TRUE.

[0230] 2.5 Split Tree Structure in AVS3

[0231] In AVS3, Extended Quadtree (EQT) segmentation is employed, which further extends the QTBT scheme and increases segmentation 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. Simultaneously, EQT segmentation allows for interleaving with BT segmentation to enhance adaptability.

[0232] Using EQT partitioning, the parent CU is divided into four child CUs of different sizes. As shown in Figure 7, EQT horizontally divides the M×N parent CU into two M×N / 4 CUs and two M / 2×N / 2 CUs. Similarly, EQT vertically partitions to generate two N×M / 4 CUs and two M / 2×N / 2 CUs. Notably, the size of the EQT child blocks is always a power of 2, thus eliminating the need for additional transformations.

[0233] In the QTBT structure, the signaling first notifies the QT partition flag to indicate whether the current CU is QT partitioned. Then, when this flag is false, a second signal is encoded to indicate whether the current CU partitioning mode is non-partitioned or BT partitioned. For BT partitioned CUs, the signaling notifies a third bit (DIR) to distinguish between horizontal and vertical BT partitions. When EQT partitioning is introduced, if both BT and EQT are available, the signaling notifies an additional bit called isEQT to indicate whether it is an EQT partition, such as... Figure 8 As shown.

[0234] 2.6 UQT

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

[0236] 3. Shortcomings and problems of the existing system

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

[0238] 4. Exemplary methods 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 detailed invention described below should be considered as an example to explain general concepts. These embodiments should not be interpreted in a narrow sense. Furthermore, these embodiments can be combined in any way.

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

[0242] QT, BT, TT, UQT, or EQT can 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] The proposed definition of the segmentation type

[0245] 1. A penttree (QUI-T) partitioning method was proposed. Using QUI-T, a block of dimension W×H is divided into five smaller blocks. When the indication for this partitioning is true, such a block is directly partitioned into five smaller blocks (also called sub-blocks). The smaller blocks can be considered as encoding / decoding 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 recursively.

[0247] b. In one example, all dimensions are in the form of 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 the space into blocks in both the horizontal and vertical directions. This is called a mixed orientation. 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 only one block 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 only one block 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 It has a different block size compared to other partitions.

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

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

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

[0260] iii. In one example, H x =1 / 2H and H y = 1 / 8H (y != x). Alternatively, x can also be 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 [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, 64.

[0263] g. In one example, the two segments in a segmentation can have equal dimensions (size equal to W). x ×H x Other segments have the same but different dimensions from these two segments.

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

[0265] 1. Figure 10CAn example is given, where W1 = W3 = 1 / 8W and W y =1 / 4W(y!=3&&y!=1).

[0266] ii. In one example, H x =1 / 8H and H y = 1 / 4H (for all y != x). Alternatively, x can also be 0 and 3. Alternatively, x can also be 0 and 4. Alternatively, x can also be 1 and 3. Alternatively, x can also be 1 and 4.

[0267] h. In one example, the two segments in a segmentation can have equal dimensions (size equal to W). x ×H x The other three segments 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, and k are not equal to x.

[0269] 1. Figure 10C Examples are given, where W0 = W4 = 1 / 16W; W1 = 2 / 16W; W2 = 4 / 16W and W3 = 8 / 16W.

[0270] ii. In one example, for two segments with equal dimensions, H x = 1 / 16H; and 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 segments may have equal dimensions (size equal to W). x ×H x Two of the remaining three segments have the same size.

[0272] i. In the descriptions above and below, 1 / 16W or 1 / 8W means 1 / 16×W or 1 / 8×W, or written 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] l. In one example, when the current block is partitioned using a quinary partition, one or more sub-blocks are not allowed to be partitioned into one or more sub-blocks.

[0276] i. For example, if the current block is divided into five sub-blocks by a quinary partition: 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 divided by vertical BT, where x can be one or more of 0, 1, 2, 3, and 4;

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

[0279] 3. In one example, Bx is not allowed to be divided by the level BT, where x can be one or more of 0, 1, 2, 3, and 4;

[0280] 4. In one example, Bx is not allowed to be divided by the level TT, where x can be one or more of 0, 1, 2, 3, and 4;

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

[0282] ii. For example, if the current block is divided into five sub-blocks by a quinary partition: 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 divided by the level BT, where x can be one or more of 0, 1, 2, 3, and 4;

[0284] 2. In one example, Bx is not allowed to be divided by the level TT, where x can be one or more of 0, 1, 2, 3, and 4;

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

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

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

[0288] m. The above method can be extended to other hexadecimal, septenary, and octonary tree partitions (SnT, StT, OctT), where a block can be divided into 6, 7, or 8 smaller blocks. An example of hexadecimal partitioning is... Figure 11A and Figure 11B As shown in the image.

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

[0290] o. The encoding / decoding order (represented by PIdx 0..4) can be compared with... Figures 10A-10E The definitions differ.

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

[0292] ii. Alternatively, multiple encoding / decoding orders can be predefined for a QUI-T pattern, and a block can select one of them, such as by signaling the selected encoding / decoding order on the decoder side or by deducing an instruction.

[0293] Interaction with other segmentation types

[0294] 2. A block that is divided into sub-blocks by QUI-T can be divided from the parent block by one or more specific types of partitioning methods.

[0295] a. Blocks that can be split by QUI-T can be blocks generated by splitting by QT, BT, TT, or QUI-T.

[0296] b. For example, a block that can be divided into sub-blocks by QUI-T can only be divided from the parent block by QT.

[0297] c. A block that can be QUI-T split can be the root block.

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

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

[0300] b. For example, a block partitioned from a parent block via QUI-T can be further partitioned into child blocks via BT and / or TT and / or QUI-T (but not via QT).

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

[0302] d. For example, a block partitioned from a parent block via QUI-T cannot be further partitioned into child blocks via QT.

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

[0304] 4. When a parent block is divided into child blocks using QUI-T, the division depth of the child blocks can be derived from the division depth of the parent block.

[0305] a. In one example, the QUI-T partition can be used to update the QT / BT / TT / QUI-T / MTT depth.

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

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

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

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

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

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

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

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

[0314] i. Depth increment depends on the ratio of child block to parent block.

[0315] QUI-T usage limitations

[0316] 5. In one example, the maximum / minimum block size that can be allowed for QUI-T splits and / or the maximum bit depth that can be allowed for QUI-T splits and / or the maximum depth can be signaled in SPS / PPS / VPS / APS / sequence header / picture header / strip header / fragment header / CTU line / region, etc.

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

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

[0319] c. For example, the largest block that can be partitioned by QUI-T can be a virtual pipeline data unit (VPDU).

[0320] d. In one example, the maximum / minimum block size that can be allowed for QUI-T splitting and / or the maximum depth that can be allowed for QUI-T splitting may depend on the standard tier.

[0321] e. In one example, the maximum / minimum block size that can be allowed for QUI-T splitting and / or the maximum depth that can be allowed for QUI-T splitting can be derived, as in the same way used for QT splitting.

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

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

[0324] h. When dividing a block according to QUI-T, the corresponding depth of QUI-T for a smaller block can be adjusted accordingly (e.g., increased by 1).

[0325] i. Alternatively, the corresponding depth of a specific segment (e.g., QT) of a smaller block can be adjusted accordingly (e.g., increased by 1).

[0326] ii. Alternatively, the corresponding MTT depth of a smaller block can be adjusted accordingly (e.g., increased by 1).

[0327] iii. Adjustments to the corresponding depths of different smaller blocks can be made in the same way (e.g., by increasing by 1).

[0328] 1. Alternatively, the adjustment of the corresponding depth of different smaller blocks can be done in different ways (e.g., by increasing by 1). For example, the adjustment depends on the block dimension of the smaller block.

[0329] 6. QUI-T is not allowed if a partitioned sub-block spans multiple Virtual Pipeline Data Units (VPDUs).

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

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

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

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

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

[0335] d. QUI-T is not allowed if W <= T1 or H <= T2;

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

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

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

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

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

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

[0342] k.T1, T2 and T can be signaled from the encoder to the decoder in the form of VPS / SPS / PPS / picture header / strip header / group header / film header.

[0343] l. T1, T2, and T can depend on the color components. For example, T1, T2, and T can be different for the luminance and chrominance components.

[0344] i. In one example, the thresholds such as T1, T2 and / or T that are signaled can be shared by QUI-T and TT.

[0345] ii. In one example, the thresholds such as T1, T2 and / or T that are signaled can be shared by QUI-T and BT.

[0346] m. T1, T2, and T can 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, then T1, T2, and T can be different for the luma and chroma components.

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

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

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

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

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

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

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

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

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

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

[0357] g. If H <= T, then the level QUI-T is allowed; for example, T = 64.

[0358] h. If H >= T, then the level QUI-T is allowed; for example, T = 32.

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

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

[0361] k.T1, T2 and T can be signaled from the encoder to the decoder in the form of VPS / SPS / PPS / picture header / strip header / group header / film header.

[0362] i. In one example, the thresholds such as T1, T2 and / or T that are signaled can be shared by QUI-T and TT.

[0363] ii. In one example, the thresholds such as T1, T2 and / or T that are signaled can be shared by QUI-T and BT.

[0364] l. T1, T2, and T can depend on the color components. For example, T1, T2, and T can be different for the luminance and chrominance components.

[0365] m. T1, T2, and T can 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, then T1, T2, and T can be different for the luma and chroma components.

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

[0367] a. If the partition depth is less than or equal to T, then QUI-T is not allowed;

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

[0369] c. If the QT partition depth is less than or equal to T, then QUI-T is not allowed;

[0370] d. If the QT partition depth is greater than or equal to T, then QUI-T is not allowed;

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

[0372] f. If the BT partition depth is less than or equal to T, then QUI-T is not allowed;

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

[0374] h. If the partition depth TT is less than or equal to T, then QUI-T is not allowed;

[0375] i. If the QUI-T partition depth is less than or equal to T, then QUI-T is not allowed;

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

[0377] k. If the MTT partition depth is less than or equal to T, then QUI-T is not allowed;

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

[0379] mT can send signaling notifications from the encoder to the decoder in the form of VPS / SPS / PPS / image header / strip header / group header / film header.

[0380] nT can depend on the color components. For example, T1, T2, and T can be different for the luminance and chrominance components.

[0381] oT can 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, then T1, T2, and T can be different for the luma and chroma components.

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

[0383] a. If the partition depth is less than or equal to T, then QUI-T is allowed;

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

[0385] c. If the QT partition depth is less than or equal to T, then QUI-T is allowed;

[0386] d. If the QT partition depth is greater than or equal to T, then QUI-T is allowed;

[0387] e. If the BT partitioning depth is greater than or equal to T, then QUI-T is allowed;

[0388] f. If the BT partition depth is less than or equal to T, then QUI-T is allowed;

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

[0390] h. If the partition depth TT is less than or equal to T, then QUI-T is allowed;

[0391] i. If the QUI-T partition depth is less than or equal to T, then QUI-T is allowed;

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

[0393] k. If the MTT partition depth is less than or equal to T, then QUI-T is allowed;

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

[0395] mT can send signaling notifications from the encoder to the decoder in the form of VPS / SPS / PPS / image header / strip header / group header / film header.

[0396] nT can depend on the color components. For example, T1, T2, and T can be different for the luminance and chrominance components.

[0397] The time-of-use (OT) mechanism can depend on whether the luma and chroma codecs are separate. For example, if the luma and chroma codecs are separate, then for the luma and chroma components,

[0398] T1, T2, and T can be different.

[0399] 11. Whether and how to use QUI-T can depend on the position of the current block. For example, whether and how to use QUI-T can depend on whether the current block crosses the boundary of an image / piece / piece group.

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

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

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

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

[0404] e. In one example, mixing QUI-T might not be allowed if the current block crosses the right boundary of the picture / piece / piece group.

[0405] f. In one example, if the current block crosses the bottom boundary of the picture / piece / piece group, mixing QUI-T may not be allowed.

[0406] g. In one example, if a sub-block defined by QUI-T is completely outside of the picture / piece / piece group, then that sub-block can be omitted during encoding / decoding.

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

[0408] i. Parts other than the image can be omitted during the encoding / decoding process.

[0409] ii. The portion within the image can be further subdivided.

[0410] iii. The portion within the image can be encoded and decoded into CU.

[0411] 1. Whether a portion of an image is encoded as a CU can depend on the width (w) and height (h) of that portion.

[0412] a. In one example, if w = 2n w h = 2n h The portion within the image can be encoded and decoded into a CU, where n w and n h It is an integer.

[0413] i. In one example, QUI-T is not allowed if any sub-blocks divided by QUI-T are partially / entirely outside of the picture / piece / piece group.

[0414] 12. When QUI-T or certain QUI-T patterns are not allowed, the signaling used to indicate the use of the pattern can also be skipped.

[0415] a. Alternatively, it can still be signaled, but is restricted to false in the consistent bitstream.

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

[0417] a.QT

[0418] b. Horizontal BT

[0419] c. Vertical BT

[0420] d. Horizontal TT

[0421] e. Vertical BT

[0422] f. Horizontal UQT

[0423] g. Vertical UQT

[0424] h.QUI-T

[0425] It is proposed that QUI-T can be applied only to leaf nodes, for example, when a block is not further divided according to other partitions.

[0426] i. In one example, a signaling method can be used to notify leaf nodes whether a QUI-T flag is being used.

[0427] i. Alternatively, further signaling may be used to indicate which QUI-T to use.

[0428] j. Alternatively, leaf node signaling notifications may indicate whether QUI-T or which type of QUI-T is disabled.

[0429] QUI-T Usage Instructions

[0430] 14. Whether to apply QUI-T and / or which QUI-T to apply can be notified to the decoder via encoder signaling.

[0431] a. In one example, it can be signaled in VPS / SPS / PPS / sequence header / image header / strip header / fragment header / fragment header to indicate whether QUI-T can be applied.

[0432] b. In one example, it can be signaled in VPS / SPS / PPS / sequence header / picture header / strip header / fragment header / fragment header to indicate which QUI-T can be applied.

[0433] c. In one example, it can be signaled within the block to indicate whether QUI-T should be used to divide the block.

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

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

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

[0437] 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 sequence or mixed content captured by the camera) / strip type / picture type / set type / low latency check flag.

[0438] 15. A syntax element can be signaled to indicate that there is no partition or split (including the type and direction of the partition).

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

[0440] 16. The split instruction can be represented by two syntax elements: first, the selected split tree type can be signaled, followed by the split direction if necessary.

[0441] a. In one example, a split tree type index can be signaled within a block to indicate whether the block was split by QT, QUI-T, or not.

[0442] i. Alternatively, further signaling may be provided to indicate the division direction (horizontal / vertical / mixed direction) and / or the division pattern.

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

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

[0445] ii. Alternatively, further signaling may be provided to indicate the division direction (horizontal / vertical) and / or the division pattern.

[0446] c. Alternatively, the indication of the partitioning direction can be first notified by signaling, followed by the partitioning tree type (such as QT, TT, QUI-T).

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

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

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

[0450] 1. If only vertical segmentation is valid, the flag is not signaled, and horizontal segmentation is inferred to be used.

[0451] 2. If only horizontal segmentation is valid, the flag is not signaled, and vertical segmentation is inferred to be used.

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

[0453] i. In one example, based on previous signaling notifications or derived information, the candidate BT, TT, or QUI-T to be signaled are either vertically or horizontally segmented.

[0454] ii. In one example, the first flag is signaled to indicate whether QUI-T is used. 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.

[0455] 1. In the alternative example, the binary codewords representing BT, TT, and QUI-T1 are XX, XY, and Y, respectively.

[0456] iii. In one example, truncated unary codes are applied. For example, the binary codewords representing BT, TT, QUI-T1, QUI-T2, QUI-T3, and QUI-T4 are X, YX, YYX, YYYX, YYYYX, and YYYYY, respectively.

[0457] iv. In one example, the first flag is signaled to indicate whether BT is used. If BT is not used, the second flag is signaled to indicate whether QUI-T is used. If QUI-T is used, the specific type of QUI-T used is further specified. 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.

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

[0459] a. In one example, based on previously notified or derived information, the candidate BT, TT, or QUI-T to be notified are either vertically or horizontally segmented.

[0460] b. For example, disallowed or invalid partitions cannot be signaled from the encoder to the decoder, i.e., there is no codeword to represent disallowed or invalid partitions.

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

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

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

[0464] 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).

[0465] ii. For example, no codeword represents an invalid partition. In other words, invalid partitions are skipped when the codeword table is built.

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

[0467] g. In one example, if only one QUI-T is valid, and the signaling notification indicates the use of a QUI-T, then no further information is provided by the signaling notification indicating which QUI-T is being used. A valid QUI-T is used implicitly.

[0468] h. In one example, if only two QUI-Ts are valid, and the signaling indicates the use of a QUI-T, then a flag is signaled to indicate which QUI-T to use.

[0469] i. In one example, if only three QUI-Ts are valid, and signaling indicates the use of a QUI-T, then a signaling message is sent to indicate which QUI-T to use. For example, the binary codewords representing the three QUI-Ts are X, YX, and YY, respectively.

[0470] j. In one example, the binarylization and / or signaling method does not change based on which partition within the block is valid. Invalid partitions cannot be selected in a consistent bitstream.

[0471] 18. The segmentation indication can be encoded or decoded using arithmetic encoding and decoding of one or more contexts.

[0472] a. In one example, you can use context to encode and decode only a portion of the bit string, and you can use a bypass mode (i.e., without using context) to encode and decode the remaining bits.

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

[0474] c. Alternatively, all bits of the bit string can be encoded and decoded using a bypass mode.

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

[0476] e. The context can depend on:

[0477] i. The position or index of the bit.

[0478] ii. Spatial / temporal neighbor block segmentation.

[0479] iii. The current partition depth of the current block (e.g., QT depth / BT depth / TT depth / QUI-T depth / MTT depth).

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

[0481] v. Encoding / decoding mode for spatial / temporal neighboring blocks.

[0482] vi. Width / height of spatial / temporal neighboring blocks.

[0483] vii. Width / height of the current block.

[0484] viii. Strip type / Image type / Piece group type.

[0485] ix. Color component.

[0486] x. Statistical results from the segmentation types of previous encoded / decoded blocks.

[0487] 19. Whether and / or how to use QUI-T can depend on the color format (such as 4:4:4 or 4:2:0) and / or color components.

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

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

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

[0491] The examples described above can be used in the context of the methods described below, such as method 1300, which can be implemented at the video decoder / encoder.

[0492] Figure 13 A flowchart of an exemplary method for video processing is shown. Method 1300 includes, in step 1310, determining a segmentation pattern for dividing the current video block into M parts, where M>4, based on segmentation information. In some embodiments, the size of the current video block is W×H, and the i-th part of the M parts is M. i The size is W i ×H i W, H, W i and H i Let i be an integer, i = 0 to M-1.

[0493] The method also includes step 1320, performing a conversion of the current video block.

[0494] Figure 14 A flowchart of an exemplary method for video processing is shown. Method 1400 includes: in step 1410, determining whether it is permissible to divide the current video block into five sub-blocks by a penttree (QUI-T) partition, based on whether the current video block meets certain conditions; and in step 1420, performing a transformation of the current video block based on the determination.

[0495] The following examples can be used to describe some embodiments and techniques related to methods 1300 and 1400.

[0496] In one example, a method for video processing is disclosed, comprising: determining a segmentation pattern for dividing a current video block into M parts, where M>4, based on segmentation information; and performing a transformation of the current video block based on the segmentation pattern; wherein the size of the current video block is W×H, and the i-th part of the M parts is M i The size is W i ×H i W, H, W i and H i It is an integer, i = 0 to M-1.

[0497] In one example, in split mode, a penttree (QUI-T) is used to divide the current video chunk into five parts.

[0498] In one example, at least one of the M parts can be further recursively divided into multiple sub-parts.

[0499] In one example, at least one of the widths and heights of the M parts has a value that is a power of 2.

[0500] In one example, the current video block is divided in both horizontal and vertical directions.

[0501] In one example, at least one of the M parts has a width smaller than the width of the current video block, or a height smaller than the height of the current video block.

[0502] In one example, the current video block is divided only in one of the horizontal and vertical directions.

[0503] In one example, if the current video block is divided only in the vertical direction, then each of the M parts has the same height as the current video block, and if the current video block is divided only in the horizontal direction, then each of the M parts has the same width as the current video block.

[0504] In one example, M parts are divided into two groups, the first group includes at least one part, and the second group includes the remaining parts, wherein at least one part has a first size, and at least one of the remaining parts has a second size different from the first size.

[0505] In one example, the first group includes only one part with a first size, and each of the remaining parts has a second size.

[0506] In one example, only one part has a width of W / 2, and each of the remaining parts has a width of W / 2*(M-1); and the current video block is divided vertically, and the M parts are arranged from left to right in the order of index i.

[0507] In one example, only one part has a height of H / 2, and each of the remaining parts has a height of H / 2*(M-1); and the current video block is divided horizontally, and the M parts are arranged from top to bottom in order of index i.

[0508] In one example, M = 5, and the current video block is divided into five parts using a penttree (QUI-T); and each part is either M1 or M3.

[0509] In one example, M = 5, and the current video chunk is divided into five parts using a penttree (QUI-T); only one part has a width W - ((W / K) << 2), and each of the remaining parts has a width W / K.

[0510] In one example, K equals one of 5, 8, 16, 32, or 64.

[0511] In one example, the first group consists of two parts with a first size, and each of the remaining parts has a second size.

[0512] In one example, each of the two parts has a width of W / 2*(M-1), and each of the remaining parts has a width of W / (M-1); and the current video block is divided vertically, and the M parts are arranged from left to right in the order of index i.

[0513] In one example, each of the two parts has a height of H / 2*(M-1), and each of the remaining parts has a height of H / (M-1); and the current video block is divided horizontally, and the M parts are arranged from top to bottom in order of index i.

[0514] In one example, M = 5, and the current video chunk is divided into five parts using a penttree (QUI-T); these two parts belong to one of the following sets:

[0515] {M0,M3};

[0516] {M0,M4};

[0517] {M1,M3}; and

[0518] {M1,M4}.

[0519] In one example, the first group includes two parts having a first size, and the remaining group includes at least one part having a size different from the second size.

[0520] In one example, M = 5, and the current video chunk is divided into five parts using a penttree (QUI-T); each of the two parts has a width of W / 16, and the remaining parts have widths of W / 8, W / 4, and W / 2 respectively.

[0521] In one example, the current video block is divided vertically, and the M parts are arranged from left to right in the order of index i; W0 = W4 = W / 16, and W1 = W / 8, W2 = W / 4, and W3 = W / 2.

[0522] In one example, M = 5, and the current video chunk is divided into five parts using a penttree (QUI-T); each of the two parts has a height of H / 16, and the remaining parts have heights of H / 8, H / 4, and H / 2, respectively.

[0523] In one example, M = 5, and the current video chunk is divided into five parts using a penttree (QUI-T); each of the two parts has a first size, and the remaining part consists of two parts with a second size and a third size that is different from the second size.

[0524] In one example, M equals one of 6, 7, and 8.

[0525] In one example, M = 5, and a penttree (QUI-T) is used to divide the current video chunk into five parts in both the vertical and horizontal directions.

[0526] W0 + W1 + W2 = W3 + W4 = W;

[0527] H0 = H1 = H2; H3 = H4; and

[0528] H0 + H3 = H.

[0529] In one example, M = 5, and a penttree (QUI-T) is used to divide the current video chunk into five parts in both the vertical and horizontal directions.

[0530] W1 = W2;

[0531] W0 + W1 = W3 + W4 = W;

[0532] H0 = H1 + H2;

[0533] H3 = H4; and

[0534] H0 + H3 = H.

[0535] In one example, M = 5, and a penttree (QUI-T) is used to divide the current video chunk into five parts in both the vertical and horizontal directions.

[0536] W0 + W1 + W2 + W4 = W;

[0537] W2 = W3; and

[0538] H0 = H1 = H2 + H3 = H4 = H.

[0539] In one example, the current video block is divided vertically, and the M parts are arranged from left to right in order of index i; and

[0540] W0+W1+W2+…+W i ..+W M-1 =W;

[0541] H0 = H1 = H2 = … = H i …=H M-1=H, where 0<=i<=M-1.

[0542] In one example, M = 5, and a penttree (QUI-T) is used to divide the current video chunk into five parts; where

[0543] W0 = W4 = W / 8, W1 = W2 = W3 = W / 4; and

[0544] H0 = H1 = H2 = H3 = H4 = H.

[0545] In one example, the current video block is divided horizontally, and the M parts are arranged from top to bottom in order of index i; where

[0546] H0+H1+H2+…+H j …+H M-1 =H; and

[0547] W0 = W1 = W2 = … = W j …=W M-1 =W, where 0<=j<=M-1.

[0548] In one example, M = 5, and a penttree (QUI-T) is used to divide the current video chunk into five parts; where

[0549] H0 = H4 = H / 8, H1 = H2 = H3 = H / 4; and

[0550] W0 = W1 = W2 = W3 = W4 = W.

[0551] In one example, M = 6,

[0552] W4=1 / 2W; W0=W5=1 / 16W; W1=W2=W3=1 / 8W.

[0553] In one example, M=6, and the current video block is divided in both the vertical and horizontal directions, and

[0554] W0 + W1 + W2 = W;

[0555] H0 = H1 = H2;

[0556] W0 = W3 = W4;

[0557] W3 + W5 = W;

[0558] H0 + H3 + H4 = H; and

[0559] H1 + H5 = H.

[0560] In one example, if the current video block is divided with a specific segmentation pattern, it is not allowed to apply a specific segmentation tree to at least one of the M parts, and the specific segmentation tree includes at least one of a vertical binary tree (BT), a vertical ternary tree (TT), a horizontal BT, a horizontal TT, and a quadtree (QT).

[0561] In one example, M = 5, and the current video block is divided into five parts in the vertical direction using a penttree (QUI-T), with M0 to M4 arranged from left to right in the order of index i; and wherein, in a particular segmentation pattern, M0 to M4 have dimensions of W / 8×H, W / 4×H, W / 4×H, W / 4×H, and W / 8×H, respectively.

[0562] In one example, M = 5, and the current video block is divided into five parts horizontally using a penttree (QUI-T), with M0 to M4 arranged from top to bottom in the order of index i; and wherein, in a particular segmentation pattern, M0 to M4 have dimensions of W×H / 8, W×H / 4, W×H / 4, W×H / 4, and W×H / 8 respectively.

[0563] In one example, each of the M parts is indicated by an index, and the M parts are transformed in the order of the indices.

[0564] In one example, the segmentation pattern includes at least one segmentation pattern, and one or more transformation orders are predefined for the at least one segmentation pattern, and the method includes: for the at least one segmentation pattern, determining an indication for indicating which transformation order is used to transform M parts.

[0565] In one example, the indication is either notified from the encoding side signaling or derived from the decoding side.

[0566] In one example, the partitioning information is contained in the bitstream representation of the video, which includes the current video block.

[0567] In one example, at least one part of the current video block is at least one of the encoding / decoding unit, prediction unit, and transform unit.

[0568] In one example, a method for video processing is disclosed, comprising: determining whether it is permissible to divide the current video block into five sub-blocks by a penttree (QUI-T) partition based on whether the current video block meets certain conditions; and performing a transformation of the current video block based on the determination.

[0569] In one example, specific conditions include: the current video block was partitioned from the parent block by at least one of quadtree (QT), binary tree (BT), ternary tree (TT), and QUI-T partitioning.

[0570] In one example, the current video block is split from the parent block using QT splitting.

[0571] In one example, a specific condition is that the current video block is the root block.

[0572] In one example, the method further includes dividing at least one of the five sub-blocks into multiple parts using at least one specific segmentation pattern.

[0573] In one example, at least one specific segmentation pattern includes at least one of BT segmentation and TT segmentation.

[0574] In one example, at least one specific segmentation pattern includes at least one of BT segmentation, TT segmentation, and QUI-T segmentation, but excludes QT segmentation.

[0575] In one example, the at least one specific segmentation pattern includes at least one of QUI-T segmentation and QT segmentation, but excludes BT segmentation and TT segmentation.

[0576] In one example, at least one particular segmentation pattern does not include QT segmentation.

[0577] In one example, none of the five sub-blocks can be further divided.

[0578] In one example, the partitioning depth of at least one sub-block depends on the partitioning depth of the current video block.

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

[0580] In one example, the partition depth is at least one of QT partition depth, BT partition depth, TT partition depth, QUI-T partition depth, and Multi-Type Tree (MTT) partition depth.

[0581] In one example, different sub-blocks have different partitioning depth increments in at least one of QUI-T partitioning, BT partitioning, TT partitioning, QT partitioning, and MTT partitioning.

[0582] In one example, at least one sub-block has a partition depth increment that depends on the ratio of the at least one sub-block to the current video block in size.

[0583] In one example, at least one sub-block of the current video block is at least one of the encoding / decoding unit, prediction unit, and transform unit.

[0584] In one example, the transformation 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.

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

[0586] 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 performing the methods in any of the above examples.

[0587] 5. Example implementations of the disclosed technology

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

[0589] In some embodiments, the video encoding / decoding method may use, as referenced Figure 12 The device described herein is implemented on a hardware platform.

[0590] As can be understood from the foregoing, specific embodiments of the technology disclosed herein have been described for illustrative purposes, but various modifications can be made without departing from the scope of the invention. Therefore, the technology disclosed herein is not limited to those specified in the appended claims.

[0591] The embodiments of the subject matter and functional operation 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 combinations of one or more of them. Embodiments 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 or control of the operation of a data processing apparatus. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a combination of materials that implement machine-readable propagation signals, or a combination of one or more of them. The terms "data processing unit" or "data processing apparatus" encompass all means, devices, and machines for processing data, including, for example, a programmable processor, a computer, or a plurality of processors or computers. In addition to hardware, the apparatus may also include code that creates an operating environment for the computer program in question, for example, code constituting processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

[0592] Computer programs (also known as programs, software, software applications, scripts, or code) can be written in any programming language, including compiled or interpreted languages, and can be deployed in any form, including as standalone programs or as modules, components, subroutines, or other units suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored as a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), as a single file dedicated to the program in question, or as multiple coordinating files (e.g., a file storing one or more modules, subroutines, or portions of code). Computer programs can be deployed to execute on one or more computers located at a single site or distributed across multiple sites interconnected by a communication network.

[0593] The processes and logic flows described in this specification can be executed by one or more programmable processors that run one or more computer programs to perform functions by manipulating input data and generating output. The processes and logic flows can also be executed by dedicated logic circuitry, and the device can be implemented as dedicated logic circuitry, such as an FPGA (Field-Programmable Gate Array) or an ASIC (Application-Specific Integrated Circuit).

[0594] For example, processors suitable for executing computer programs include general-purpose and special-purpose microprocessors, as well as any one or more processors in any type of digital computer. Typically, a processor receives instructions and data from read-only memory or random access memory, or both. The basic components of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, a computer will also include one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks, or operatively coupled to receive data from or transfer data to one or more mass storage devices, or both. However, a computer does not necessarily need 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 semiconductor memory devices such as EPROM, EEPROM, and flash memory devices. The processor and memory may be supplemented or incorporated into special-purpose logic circuitry.

[0595] This specification and accompanying drawings are to be considered exemplary only, where exemplary means example. As used herein, the singular forms “a,” “an,” and “the” are also intended to include the plural forms, unless the context clearly indicates otherwise. Furthermore, the use of “or” is intended to include “and / or”, unless the context clearly indicates otherwise.

[0596] While this patent document contains numerous details, these should not be construed as limiting any invention or the scope of the claims, but rather as descriptions of features characteristic of specific embodiments of a particular invention. Certain features described in the context of individual embodiments in this patent document 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 individually or in any suitable sub-combination in multiple embodiments. Furthermore, although the foregoing features may be described as functioning in certain combinations, or even initially claimed in this manner, in some cases one or more features may be removed from the claimed combination, and the claimed combination may refer to a sub-combination or a variation of a sub-combination.

[0597] Similarly, although operations are described in a specific order in the accompanying drawings, this should not be construed as requiring these operations to be performed in the specific order or sequence shown, or requiring all of the shown operations to obtain the desired result. Furthermore, the separation of various system components in the embodiments described in this patent document should not be construed as requiring such separation in all embodiments.

[0598] Only a few implementation methods and examples are described, and other implementations, enhancements and variations can be made based on the content described and illustrated in this patent document.

Claims

1. A method of video processing, comprising: determining, according to partition information, for a current video block of a video, a split mode that partitions the current video block into M parts, where M > 4; and performing a conversion of the current video block based on the split mode; wherein a size of the current video block is WxH, and a size of an i-th part M i of the M parts is W i xH i , W, H, W i , and H i are integers, and index i = 0 to M-1; wherein the split mode at least includes: M = 5, and the current video block is partitioned into five parts using a quad-tree (QUI-T) in both vertical and horizontal directions, and W0 + W1 + W2 = W3 + W4 = W; H0 = H1 = H2; H3 = H4; and H0 + H3 = H.

2. The method of claim 1, wherein, In the split mode, the current video block is partitioned into five parts using the quad-tree (QUI-T).

3. The method of claim 1 or 2, wherein, At least one of the M parts can be further recursively partitioned into sub-parts.

4. The method of claim 1, wherein, At least one of a width and a height of at least one of the M parts has a value of a power of 2.

5. The method of claim 1, wherein, The current video block is partitioned in both horizontal and vertical directions.

6. The method of claim 5, wherein, A width of at least one part of the M parts is less than a width of the current video block, or a height thereof is less than a height of the current video block.

7. The method of claim 1, wherein, The M parts are divided into two groups, and a first group includes at least one part, and a second group includes remaining parts, wherein the at least one part has a first size, and at least one of the remaining parts has a second size different from the first size.

8. The method of claim 7, wherein, The first group includes two parts having the first size, and each of the remaining parts has the second size.

9. The method of claim 7, wherein, The first group includes two parts each having the first size, and the remaining parts include at least one part having a size different from the second size.

10. The method of claim 9, wherein, The split mode at least further includes: M = 5, and the current video block is partitioned into five parts using the quad-tree (QUI-T); each of the two parts has the first size, and the remaining parts include two parts each having the second size and one part having a third size different from the second size.

11. The method of claim 1, wherein, The split mode at least further includes: M = 5, and the current video block is partitioned into five parts using the quad-tree (QUI-T) in both vertical and horizontal directions, and W1 = W2; W0 + W1 = W3 + W4 = W; H0 = H1 + H2; H3 = H4; and H0 + H3 = H.

12. The method of claim 1, wherein, The split mode at least further includes: M = 5, and the current video block is partitioned into five parts using the quad-tree (QUI-T) in both vertical and horizontal directions, and W0 + W1 + W2 + W4 = W; W2 = W3; and H0 = H1 = H2 + H3 = H4 = H.

13. The method of claim 1, wherein, The split mode at least further includes: M = 6, and the current video block is partitioned in both vertical and horizontal directions, and W0 + W1 + W2 = W; H0 = H1 = H2; W0 = W3 = W4; W3 + W5 = W; H0 + H3 + H4 = H; and H1 + H5 = H.

14. The method of claim 1 or 2, wherein, If the current video block is partitioned with a particular partition pattern, a particular partition tree is not allowed to be applied to at least one of the M parts, and the particular partition tree comprises at least one of a vertical binary tree (BT), a vertical ternary tree (TT), a horizontal BT, a horizontal TT, and a quad tree (QT).

15. The method of claim 1, wherein, Each of the M parts is indicated with an index, and the M parts are converted in an order of the indices.

16. The method of claim 1, wherein, The partition mode comprises at least one partition pattern, and one or more conversion orders are predefined for the at least one partition pattern, and the method comprises: For the at least one partition pattern, determining an indication indicating which conversion order is used to convert the M parts.

17. The method of claim 16, wherein, The indication is signaled from an encoding side or derived at a decoding side.

18. The method of claim 1, wherein, The partition information is present in a bitstream of a video comprising the current video block.

19. The method of claim 1, wherein, At least one part of the current video block is at least one of a coding unit, a prediction unit, and a transform unit.

20. The method of claim 1, further comprising: determining whether a current video block is allowed to be partitioned into five sub-blocks by a five-ary tree (QUI-T) partition according to whether the current video block satisfies a particular condition; and performing conversion of the current video block based on the determination.

21. The method of claim 20, wherein, The particular condition comprises: The current video block is partitioned from a parent block by at least one of a quad tree (QT) partition, a binary tree (BT) partition, a ternary tree (TT) partition, and a QUI-T partition.

22. The method of claim 21, wherein, The current video block is partitioned from the parent block by a QT partition.

23. The method of claim 20, wherein, The particular condition comprises: the current video block is a root block.

24. The method of claim 20, further comprising: partitioning at least one of the five sub-blocks into parts in at least one particular partition mode.

25. The method of claim 24, wherein, The at least one particular partition mode comprises at least one of a BT partition and a TT partition.

26. The method of claim 24, wherein, The at least one particular partition mode comprises at least one of a BT partition, a TT partition, and a QUI-T partition and does not comprise a QT partition.

27. The method of claim 24, wherein, The at least one particular partition mode comprises at least one of a QUI-T partition and a QT partition and does not comprise a BT partition and a TT partition.

28. The method of claim 24, wherein, The at least one particular partition mode does not comprise a QT partition.

29. The method of claim 20, wherein, None of the five sub-blocks can be further partitioned.

30. The method of any one of claims 20-29, wherein, A partition depth of at least one sub-block depends on a partition depth of the current video block.

31. The method of claim 30, wherein, The partition depth of the at least one sub-block is equal to the partition depth of the current video block plus 1.

32. The method of claim 31, wherein, The partition depth belongs to at least one of a QT partition depth, a BT partition depth, a TT partition depth, a QUI-T partition depth, and a multi-type tree (MTT) partition depth.

33. The method of any one of claims 20-28, wherein, Different sub-blocks have different partition depth increments in at least one of a QUI-T, a BT, a TT, a QT, and a MTT partition.

34. The method of any one of claims 20-28, wherein, At least one sub-block has a partition depth increment that depends on a ratio of the at least one sub-block to the current video block in size.

35. The method of claim 20, wherein, At least one sub-block of the current video block is at least one of a coding unit, a prediction unit, and a transform unit.

36. The method of claim 1, wherein, The conversion includes encoding the current video block into a bitstream of the video, and decoding the current video block from the bitstream of the video.

37. 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 according to any one of claims 1-36.

38. A non-transitory computer-readable medium having stored thereon program instructions that, when executed by a computer, implement the method according to any one of claims 1-36.

Images