WO2017219342A1

WO2017219342A1 - Methods of signaling quantization parameter for quad-tree plus binary tree structure

Info

Publication number: WO2017219342A1
Application number: PCT/CN2016/087005
Authority: WO
Inventors: Han HUANG; Tzu-Der Chuang; Yu-Wen Huang; Ching-Yeh Chen; Shan Liu; Xiaozhong Xu
Original assignee: Mediatek Inc.
Priority date: 2016-06-24
Filing date: 2016-06-24
Publication date: 2017-12-28

Abstract

Methods of signaling quantization paramter for QTBT structure are disclosed. Including: methods for signaling delta QP, methods for reference QP derivation, and methods for signaling chroma QP offset.

Description

METHODS OF SIGNALING QUANTIZATION PARAMETER FOR QUAD-TREE PLUS BINARY TREE STRUCTURE

TECHNICAL FIELD

The invention relates generally to video processing. In particular, the present invention relates to methods and apparatuses of signaling quantization parameter for quad-tree plus binary tree structure.

BACKGROUND

High-efficiency video coding (HEVC) is the latest video coding standard developed by the Joint Collaborative Team on Video Coding (JCT-VC) . In HEVC, one slice is partitioned into multiple coding tree units (CTU) . In main profile, the minimum and the maximum sizes of CTU are specified by the syntax elements in the sequence parameter set (SPS) among the sizes of 8x8, 16x16, 32x32, and 64x64. Inside a slice, a raster scan method is used for processing the CTU.

The CTU is further partitioned into multiple coding units (CU) to adapt to various local characteristics. A quadtree denoted as the coding tree is used to partition the CTU into multiple CUs. Let CTU size be MxM where M is one of the values of 64, 32, or 16. The CTU can be a single CU or can be split into four smaller units of equal sizes of M/2xM/2, which are nodes of coding tree. If units are leaf nodes of coding tree, the units become CUs. Otherwise, the quadtree splitting process can be iterated until the size for a node reaches a minimum allowed CU size specified in the SPS. This representation results in a recursive structure specified by a coding tree as shown in Fig. 1. The solid lines indicate CU boundaries. The decision whether to code a picture area using inter picture (temporal) or intra picture (spatial) prediction is made at the CU level. Since the minimum CU size can be 8x8, the minimum granularity for switching different basic prediction type is 8x8.

One or more prediction units (PU) are specified for each CU. Coupled with the CU, the PU works as a basic representative block for sharing the prediction information. Inside one PU, the same prediction process is applied and the relevant information is transmitted to the decoder on a PU basis. A CU can be split into one, two, or four PUs according to the PU splitting type. HEVC defines eight shapes for splitting a CU into PU as shown in Fig. 2. Unlike the CU, the PU may only be split once.

After obtaining the residual block by prediction process based on PU splitting type, a CU can be partitioned into transform units (TU) according to another quadtree structure which is analogous to the coding tree for the CU as shown in Fig. 1. The solid lines indicate CU boundaries and dotted lines indicate TU boundaries. The TU is a basic representative block having residual or transform coefficients for applying the integer transform and quantization. For each TU, one integer transform having the same size to the TU is applied to obtain residual coefficients. These coefficients are transmitted to the decoder after quantization on a TU basis.

The terms coding tree block (CTB) , coding block (CB) , prediction block (PB) , and transform block (TB) are defined to specify the 2-D sample array of one color component associated with CTU, CU, PU, and TU, respectively. Thus, a CTU consists of one luma CTB, two chroma CTBs, and associated syntax elements. A similar relationship is valid for CU, PU, and TU. The tree partitioning is generally applied simultaneously to both luma and chroma, although exceptions apply when certain minimum sizes are reached for chroma.

Binary tree structure is more flexible than quadtree structure, since much more partition shapes can be supported which is also the source of coding efficiency improvement. However, the encoding complexity will also increase in order to select the best partition shape. In order to balance the complexity and coding efficiency, it was proposed to combine the quadtree and binary tree structure, which is called as quadtree plus binary tree (QTBT) structure. In the QTBT structure, a block is firstly partitioned by a quadtree structure, the quadtree splitting can be iterated until the size for a splitting block reaches the minimum allowed quadtree leaf node size. If the leaf quadtree block is not larger than the maximum allowed binary tree root node size, it can be further partitioned by a binary tree structure, the binary tree splitting can be iterated until the size (width or height) for a splitting block reaches the minimum allowed binary tree leaf node size (width or height) or the binary tree depth reaches the maximum allowed binary tree depth. In the QTBT structure, the minimum allowed quadtree leaf node size, the maximum allowed binary tree root node size, the minimum allowed binary tree leaf node width and height, and the maximum allowed binary tree depth can be indicated in the high level syntax such as in SPS. Fig. 3 illustrates an example of block partitioning (left) and its corresponding QTBT (right) . The solid lines indicate quadtree splitting and dotted lines indicate binary tree splitting. In each splitting (i.e., non-leaf) node of the binary tree, one flag indicates which splitting type (horizontal or vertical) is used, 0 indicates horizontal splitting and 1 indicates vertical splitting.

The QTBT structure can be applied separately to luma and chroma for I slice, and applied simultaneously to both luma and chroma (except when certain minimum sizes are reached for chroma) for P and B slice. That is to say that, in I slice, the luma CTB has its QTBT-structured block partitioning, and the two chroma CTBs has another QTBT-structured block partitioning.

In HEVC, delta QP signaling is controlled by two flags, cu_qp_delta_enabled_flag and diff_cu_qp_delta_depth. The former is used to indicate delta QP signaling is enabled or disabled, the latter is used to set the minimum size of units in delta QP signaling.

cu_qp_delta_enabled_flag equal to 1 specifies that the diff_cu_qp_delta_depth syntax element is present in the PPS and that cu_qp_delta_abs may be present in the transform unit syntax. cu_qp_delta_enabled_flag equal to 0 specifies that the diff_cu_qp_delta_depth syntax element is not present in the PPS and that cu_qp_delta_abs is not present in the transform unit syntax.

diff_cu_qp_delta_depth specifies the difference between the luma coding tree block size and the minimum luma coding block size of coding units that convey cu_qp_delta_abs and cu_qp_delta_sign_flag. The minimum luma coding block size of coding units is referred as quantization group. The value of diff_cu_qp_delta_depth shall be in the range of 0 to log2_diff_max_min_luma_coding_block_size, inclusive. When not present, the value of diff_cu_qp_delta_depth is inferred to be equal to 0.

log2_diff_max_min_luma_coding_block_size specifies the difference between the maximum and minimum luma coding block size. The variable, Log2MinCuQpDeltaSize, is derived as follows:

Log2MinCuQpDeltaSize ＝ CtbLog2SizeY -diff_cu_qp_delta_depth

When delta QP is applied, the final QP for a coding block is derived based on signaled delta QP and reference QP. The reference QP derivation is based on quantization group. Left qP_Abe the QP of above neighboring coded quantization group, and qP_L be the QP of left neighboring coded quantization group. If qP_Aor qP_L is not available, use aP_prev instead. qP_prev is QP of the previous quantization group in decoding order. If qP_prev is also not available, use slice QP instead. The reference QP is equal to (qP_L + qP_A+ 1) >>1.

In HEVC, chroma QP offset signaling is controlled by two flags, cu_chroma_qp_offset_enabled_flag and Log2MinCuChromaQpOffsetSize. The former indicate whether chroma QP offset signaling is enabled or disabled, the later is used to set the minimum size of units in chroma QP offset signaling.

If cu_chroma_qp_offset_enabled_flag equal to 1, then cu_chroma_qp_offset_flag is present and specifies that whether chroma qp offset is used for a block.

Log2MinCuChromaQpOffsetSize is derived as:

Log2MinCuChromaQpOffsetSize ＝ CtbLog2SizeY –diff_cu_chroma_qp_offset_depth.

diff_cu_chroma_qp_offset_depth specifies the difference between the luma coding tree block size and the minimum luma coding block size of coding units that convey cu_chroma_qp_offset_flag.

The syntax of signaling chroma QP offset at TU level is as follows:

Since the coding block is always square in HEVC, so the block size is equal to the block width or block height. However, in QTBT, there’s non-square coding block, how to signal delta QP and chroma QP offset is an issue. How to derive reference QP is also an issue. Moreover, in QTBT, luma and chroma components are separately coded, so there are two independently QuadTree+BinaryTree CU split structures for luma and chroma components, respectively. How to signal the delta QP and chroma QP offset when separating QTBT CU split structures for luma and chroma components is another issue. In the following, we propose several methods to solve these issues.

SUMMARY

In light of the previously described problems, methods of signaling quantization parameter for QTBT are proposed. First, methods of delta QP signaling for QTBT are proposed. Second, methods of chroma QP offset signaling for QTBT are proposed.

Other aspects and features of the invention will become apparent to those with ordinary skill in the art upon review of the following descriptions of specific embodiments.

BRIEF DESCRIPTION OF DRAWINGS

The invention can be more fully understood by reading the subsequent detailed description and examples with references made to the accompanying drawings, wherein:

Fig. 1 is a diagram illustrating an example of coding tree in HEVC.

Fig. 2 is a diagram illustrating the PU partition types in HEVC.

Fig. 3 is a diagram illustrating an example of QTBT partition.

DETAILED DESCRIPTION

The following description is of the best-contemplated mode of carrying out the invention. This description is made for the purpose of illustrating the general principles of the invention and should not be taken in a limiting sense. The scope of the invention is best determined by reference to the appended claims.

In QTBT, there are lots of non-square coding blocks, so delta QP signaling and chroma QP offset signaling cannot only be conditioned by the block size in one dimension as in HEVC. So, it’s proposed to signal delta QP and chroma QP offset signaling conditioned by the area of a block. A variable, MinCuQpDeltaArea or Log2MinCuQpDeltaArea, is defined and IsCUQpDeltaCoded is set as follows:

A variable, MinCuChromaQpOffsetArea or Log2MinCuChromaQpOffsetArea, is defined, and IsCuChromaQpOffsetCoded is set as follows:

In one embodiment, the variable Log2MinCuQpDeltaArea is derived as follows:

Log2MinCuQpDeltaArea ＝ 2* (CtbLog2SizeY -diff_cu_qp_delta_depth )

The variable Log2MinCuChromaQpOffsetArea is derived as:

Log2MinCuChromaQpOffsetArea ＝ 2* (CtbLog2SizeY -diff_cu_chroma_qp_offset_depth)

In another method, it’s proposed to signal delta QP and chroma QP offset conditioned by the quadtree depth and binary tree depth of a block. IsCuQpDeltaCoded and IsCuChromaQpOffsetCoded are set when coding a CU.

In one embodiment,

In another embodiment,

In still another embodiment,

In still another embodiment, when separating QTBT CU split structures for luma and chroma components, the diff_cu_qp_delta_depth can be signaled separately for luma and chroma.

In still another embodiment, when separating QTBT CU split structures for luma and chroma components, the diff_cu_qp_delta_depth can be the same for luma and chroma.

In still another embodiment, when separating QTBT CU split structures for luma and chroma components, the diff_cu_qp_delta_depth for chroma can be set as a value that depends on that of luma. For example, the value is diff_cu_qp_delta_depth-n, n can be 1, 2, et cl.

Since BT is started from the leaf of QT, we can set one constraint that the unit of delta QP and chroma QP offset signaling should be one QT leaf block. That is, one delta QP and chroma QP offset are coded and shared for all BT CUs in this QT leaf block. The minimum size of units in delta QP signaling and chroma QP offset can be signaled as the same as that in HEVC.

When separating QTBT CU split structures for luma and chroma components, it’s proposed to signal two delta QPs for luma and chroma components, respectively. Moreover, the minimum sizes of units in delta QP signaling, MinCuQpDeltaArea or Log2MinCuQpDeltaArea or Log2MinCuQpDeltaSize, can also be separately coded in sequence level, picture level, or slice level. Besides, the chroma delta QP can be predicted from the delta QP or QP of co-located luma block.

A flag (e.g. “diff_cu_qp_delta_depth_c” may be signalled to specify the difference between the chroma coding tree block size and the minimum chroma coding block size of coding units that convey cu_qp_delta_abs and cu_qp_delta_sign_flag for chroma components. The value of this flag “diff_cu_qp_delta_depth_c” shall be in the range of 0 to log2_diff_max_min_luma_coding_block_size, inclusive. When not present, the value of diff_cu_qp_delta_depth_c is inferred to be equal to 0.

In one embodiment, a flag can is signaled to indicate that whether the MinCuQpDeltaAreaC or Log2MinCuQpDeltaAreaC of chroma component is the same ratio with the chroma subsample ration. For example, in 4: 2: 0 format, the flag is indicate whether the MinCuQpDeltaAreaC is one-quarter of the MinCuQpDeltaArea, or whether the Log2MinCuQpDeltaAreaC is Log2MinCuQpDeltaArea –2.

In another embodiment, it is proposed to signal three delta QPs for each of three (e.g. Y, Cb, Cr) color component, respectively, when applicable (e.g. ChromaArrayType is greater than 0. )

In still another embodiment, it is proposed not to signal chroma QP offset if CU split structures for luma and chroma components are separated and chroma signal separate delta QP.

When separating QTBT CU split structures for luma and chroma components, it’s proposed to reuse the luma delta QP for chroma components. That is, only one delta QP is signaled for luma component, and the chroma delta QP is derived from the delta QP of co-located luma block. In this case, chroma QP offset is signaled. Furthermore, this method can be enabled or disabled at sequence level, picture level, or slice level. If this method is disabled, then two (or more) delta QPs are signaled for luma and chroma components, respectively.

When deriving reference QP for a coding block under binary tree partition, it’s difficult to identify the quantization group of current coding block and the previous quantization group in decoding order.

In one embodiment, it’s proposed to always use slice QP as reference QP for QTBT.

In another embodiment, it’s proposed to use slice QP as reference QP in the case of binary tree partition. But in the case of quadtree partition, the method in HEVC is used to derive reference QP.

In still another embodiment, it’s proposed to not use previous quantization group in decoding order as reference, instead, the slice QP is used if a neighboring coding quantization group is not available.

In still another embodiment, it’s proposed to not use previous quantization group in decoding order as reference, instead, the last coded QP in the last CTU is used if a neighboring coding quantization group is not available. If the last coded QP in the last CTU is not available, the slice QP is used instead.

In still another embodiment, the reference QP is derived as follows:

The methods described above can be used in a video encoder as well as in a video decoder. Embodiments of the methods according to the present invention as described above may be implemented in various hardware, software codes, or a combination of both. For example, an embodiment of the present invention can be a circuit integrated into a video compression chip or program codes integrated into video compression software to perform the processing described herein. An embodiment of the present invention may also be program codes to be executed on a Digital Signal Processor (DSP) to perform the processing described herein. The invention may also involve a number of functions to be performed by a computer processor, a digital signal processor, a microprocessor, or field programmable gate array (FPGA) . These processors can be configured to perform particular tasks according to the invention, by executing machine-readable software code or firmware code that defines the particular methods embodied by the invention. The software code or firmware codes may be developed in different programming languages and different format or style. The software code may also be compiled for different target platform. However, different code formats, styles and languages of software codes and other means of configuring code to perform the tasks in accordance with the invention will not depart from the spirit and scope of the invention.

The invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described examples are to be considered in all respects only as illustrative and not restrictive. To the contrary, it is intended to cover various modifications and similar arrangements (as would be apparent to those skilled in the art) . Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements.

Claims

Methods of signaling delta QP for QTBT structure, including:

1) . Signal delta QP conditioned by the area of a block；

2) . Signal delta QP conditioned by the quadtree depth and binary tree depth of a block；

3) . Set constraint that the unit of delta QP signaling should be on quandtree leaf block；

4) . Signal delta QP separately for luma and chroma components if QTBT CU split structure for luma and chroma components are separated；

5) . Reuse the luma delta QP for chroma components when separating QTBT CU split structures for luma and chroma components.
The method as claimed in claim 1, delta QP signaling is controlled by cu_qp_delta_enabled_flag and a variable MinCuQpDeltaArea.
The method as claimed in claim 2, IsCuQpDeltaCoded is set as follows:

if (cu_qp_delta_enabled_flag&&CbWidth*CbHeight>＝MinCuQpDeltaArea) {

IsCuQpDeltaCoded＝0

CuQpDeltaVal＝0

}

where CbWidth and CbHeight are the block width and block height of a coding block in QTBT, respectively.
The method as claimed in claim 1, delta QP signaling is controlled by cu_qp_delta_enabled_flag and a variable Log2MinCuQpDeltaArea.
The method as claimed in claim 4, IsCuQpDeltaCoded is set as follows:

if (cu_qp_delta_enabled_flag&& (Log2CbWidth+Log2CbHeight) >＝Log2MinCuQpDeltaArea) {

IsCuQpDeltaCoded＝0

CuQpDeltaVal＝0

}

where Log2CbWidth and Log2CbHeight are the log2 value of the block width and block height of a coding block in QTBT, respectively.
The method as claimed in claim 4, the variable Log2MinCuQpDeltaArea is derived as follows:

Log2MinCuQpDeltaArea＝2* (CtbLog2SizeY-diff_cu_qp_delta_depth) .
The method as claimed in claim 1, delta QP signaling is controlled by cu_qp_delta_enabled_flag and a variable diff_cu_qp_delta_depth.
The method as claimed in claim 7, IsCuQpDeltaCoded is set when coding a CU:

if (cu_qp_delta_enabled_flag&&quadTreeDepth+ (binaryTreeDepth>>1) <＝diff_cu_qp_delta_depth) {

IsCuQpDeltaCoded＝0

CuQpDeltaVal＝0

}

Where quadTreeDepth and binaryTreeDepth are the quadtree depth and binary tree depth of current block, respectively.
The method as claimed in claim 7, IsCuQpDeltaCoded is set when coding a CU:

if (cu_qp_delta_enabled_flag&&quadTreeDepth+ ( (binaryTreeDepth+1) >>1) <＝diff_cu_qp_delta_depth) {

IsCuQpDeltaCoded＝0

CuQpDeltaVal＝0

} .
The method as claimed in claim 7, IsCuQpDeltaCoded is set when coding a CU:

if (cu_qp_delta_enabled_flag&&2*quadTreeDepth+binaryTreeDepth<＝2*diff_cu_qp_delta_depth) {

IsCuQpDeltaCoded＝0

CuQpDeltaVal＝0

} .
The method as claimed in claim 1, it’s constraint that the unit of delta QP signaling should be one quadtree leaf block.
The method as claimed in claim 11, one delta QP is coded and shared for all binary tree CUs in this quadtree leaf block.
The method as claimed in claim 11, the minimum size of units in delta QP signaling can be signaled as the same as that in HEVC.
The method as claimed in claim 1, delta QP is separately signaled for luma and chroma components.
The method as claimed in claim 14, MinCuQpDeltaAreaC or Log2MinCuQpDeltaAreaC is separately coded for chroma components in sequence level, picture level, or slice level.
The method as claimed in claim 14, the chroma delta QP can be predicted from the delta QP or QP of co-located luma block.
The method as claimed in claim 14, a flag diff_cu_qp_delta_depth_c may be signaled to set the minimum size of units in delta QP signaling for chroma. Log2MinCuQpDeltaAreaC＝2* (CtbLog2SizeC-diff_cu_qp_delta_depth) . CtbLog2SizeC is the log 2 of CTB size of chroma.
The method as claimed in claim 17, diff_cu_qp_delta_depth_c is predicted by diff_cu_qp_delta_depth, and the difference is coded.
The method as claimed in claim 17, diff_cu_qp_delta_depth_c is inferred to be the same value as diff_cu_qp_delta_depth for luma.
The method as claimed in claim 17, MinCuQpDeltaAreaC or Log2MinCuQpDeltaAreaC for chroma and luma is the same ratio with the chroma subsample ratio. For example, in 4: 2: 0 format, the MinCuQpDeltaAreaC for chorma is one-quarter of MinCuQpDeltaArea for luma, or Log2MinCuQpDeltaAreaC＝Log2MinCuQpDeltaArea-2.
The method as claimed in claim 20, a flag is used to indicate whether MinCuQpDeltaAreaC or Log2MinCuQpDeltaAreaC of chroma and luma are the same ratio with chroma subsample ratio.
The method as claimed in claim 1, when separating QTBT CU split structures for luam and chroma components, the luma delta QP is reused for chroma components.
The method as claimed in claim 22, the delta QP of chroma is derived from the delta QP of co-located luma block.
The method as claimed in claim 23, the delta QP of chroma is set equal to the delta QP of co-located luma block.
The method as claimed in claim 23, the delta QP of chroma is set equal to the delta QP of co-located luma block plus an offset.
The method as claimed in claim 25, the offset is predefined or signaled as high level syntax, for example, at sequence level, picture level, or slice level.
The method as claimed in claim 22, reuse of luma delta QP can be enabled or disabled at sequence level, picture level, or slice level.
Methods of signaling chroma QP offset for QTBT structure, including:

1) . Signal chroma QP offset conditioned by the area of a block；

2) . Signal chroma QP offset conditioned by the quadtree depth and binary tree depth of a block；

3) . Set constraint that the unit of chroma QP offset signaling should be on quandtree leaf block.
The method as claimed in claim 28, chroma QP offset signaling is controlled by cu_chroma_qp_offset_enabled_flag and MinCuChromaQpOffsetArea.
The method as claimed in claim 29, IsCuChromaQpOffsetCoded is set as follows:

if (cu_chroma_qp_offset_enabled_flag&&CbWidth*CbHeight>＝MinCuChromaQpOffsetArea) {

IsCuChromaQpOffsetCoded＝0

}

where CbWidth and CbHeight are the block width and block height of a coding block in QTBT, respectively.
The method as claimed in claim 28, chroma QP offset signaling is controlled by cu_chroma_qp_offset_enabled_flag and a variable Log2MinChromaQpOffsetArea.
The method as claimed in claim 31, IsCuChromaQpOffsetCoded is set as follows:

if (cu_chroma_qp_offset_enabled_flag&& (Log2CbWidth+Log2CbHeight) >＝Log2MinChromaQpOffsetArea) {

IsCuChromaQpOffsetCoded＝0

}

where Log2CbWidth and Log2CbHeight are the log2 value of the block width and block height of a coding block in QTBT, respectively.
The method as claimed in claim 31, the variable Log2MinChromaQpOffsetArea is derived as follows:

Log2MinChromaQpOffsetArea＝2* (CtbLog2SizeY-diff_chroma_qp_offset_depth) .
The method as claimed in claim 28, chroma QP offset signaling is controlled by cu_chroma_qp_offest_enabled_flag and a variable diff_chroma_qp_offset_depth.
The method as claimed in claim 34, IsChromaQpOffsetCoded is set when coding a CU:

if (cu_chroma_qp_offest_enabled_flag&&quadTreeDepth+ (binaryTreeDepth>>1) <＝diff_chroma_qp_offset_depth) {

IsChromaQpOffsetCoded＝0

}

Where quadTreeDepth and binaryTreeDepth are the quadtree depth and binary tree depth of current block, respectively.
The method as claimed in claim 34, IsChromaQpOffsetCoded is set when coding a CU:

if (cu_chroma_qp_offest_enabled_flag&&quadTreeDepth+ ( (binaryTreeDepth+1) >>1) <＝diff_chroma_qp_offset_depth) {

IsChromaQpOffsetCoded＝0

} .
The method as claimed in claim 34, IsChromaQpOffsetCoded is set when coding a CU:

if (cu_chroma_qp_offest_enabled_flag&&2*quadTreeDepth+binaryTreeDepth<＝2*diff_chroma_qp_offset_depth) {

IsChromaQpOffsetCoded＝0

} .
The method as claimed in claim 28, it’s constrained that the unit of chroma QP offset signaling should be one quadtree leaf block.
The method as claimed in claim 38, one chroma QP offset is coded and shared for all binary tree CUs in this quadtree leaf block.
The method as claimed in claim 38, the minimum size of units in chroma QP offset signaling can be signaled as the same as that in HEVC.
The method as claimed in claim 28, chroma QP offset is not signaled if QTBT CU split structures for luma and chroma components are separated and chroma signal separate delta QP.
Methods of reference QP derivation for QTBT, including:

1) Always use slice QP as reference QP；

2) Use slice QP as reference QP in the case of binary tree partition, but in the case of quadtree partition, the method in HEVC is used to derive reference QP；

3) Do not use previous quantization group in decoding order as reference.
The method as claimed in claim 42, the reference QP is always slice QP. The QP for a coding block is determined by slice QP and delta QP.
The method as claimed in claim 42, coding block at the leaf node of binary tree use slice QP as reference QP. But coding block at the leaf node of quadtree use the same method as in HEVC to derive reference QP.
The method as claimed in claim 42, quantization group at quadtree node use the same method as in HEVC to derive reference QP, but quantization group at binary tree node use slice QP as reference QP.
The method as claimed in claim 42, if left neighboring coded quantization group is not available, qP_L equals slice QP, and if above neighboring coded quantization group is not available, qP_A equals slice QP. The reference QP is the average of qP_L and qP_A, i.e. (qP_L+qP_A+1) >>1.
The method as claimed in claim 42, the reference QP is derived as follows. If the QP of left and above neighboring coded quantization group are both available, use the averaged value as reference QP； else if QP of left neighboring coded quantization group is available, use QP of left neighboring coded quantization group as reference QP； else if QP of above neighboring coded quantization group is available, use QP of above neighboring coded quantization group as reference QP； else, use slice QP as reference QP.
The method as claimed in claim 42, if left neighboring coded quantization group is not available, qP_L equals the last coded QP in the last CTU, and if above neighboring coded quantization group is not available, qP_A equals the last coded QP in the last CTU. The reference QP is the average of qP_L and qP_A, i.e. (qP_L+qP_A+1) >>1. If the last coded QP in the last CTU is not available, the slice QP is used instead.