Quantization parameter signaling

Abstract

A quantization parameter signalling mechanism for both SDR and HDR content in video coding is described using two approaches. The first approach is to send the user-defined Qpc table directly in high level syntax. This leads to more flexible and efficient QP control for future 5 codec development and video content coding. The second approach is to signal luma and chroma QPs independently. This approach eliminates the need for Qpc tables and removes the dependency of chroma quantization parameter on luma QP. 20 24 20 25 36 17 A pr 2 02 4 A B S T R A C T 2 0 2 4 2 0 2 5 3 6 1 7 A p r 2 0 2 4 5

Description

1. Deriving chroma PQ based on user-defined Qpc tables 2024202536   17 Apr 2024 In accordance with embodiments of the present disclosure, chroma QP for HDR content may be determined using a user-defined Qpc table. Fig. 2 shows Table (200) representing an exemplary HDR Qpc table in accordance with an embodiment of the present disclosure. Table (200) serves essentially the same purpose for HDR content that the default SDR Qpc table 5 specified in current WC serves for SDR content. The person skilled in the art will appreciate that the disclosed approach based on a user-defined Qpc table for HDR content would unify codec design for all SDR and HDR signal types and leads to more flexible and efficient QP control for future codec development. According to an embodiment of the present disclosure, the HDR Qpc table as described may 0   be signaled directly in high level syntax such as the video parameter set (VPS), signal parameter set (SPS), PPS, adaptation parameter set (APS), slice header, and SEI message, etc. In order to reduce signaling overhead, and according to other embodiments of the present disclosure, default Qpc tables may be used as normative tables in the standard specification or as non-normative examples in the standard specification. 15 With reference to Fig. 2, and in SPS, a new syntax element chromaqptableidc may be added. A value of chroma qp table idc equal to 0 refers to the original SDR Qpc table in the VVC specification text, see table (100) in Fig. 1. When the value of chroma qp table idc is equal to 1, it refers to the table (200) of Fig. 2. In accordance with an embodiment of the present disclosure, the variable chroma qp table idc is an indication of an index to the array of Qpc 20 as a function of qPi for ChromaArrayType equal to 1. The value of chroma qp table idc may be in the range of 0 to 1, inclusive. In accordance with further embodiments of the present disclosure, either one Qpc table can be signaled and shared by both Cb and Cr, or two separate tables designed for Cb and Cr, respectively, can be signaled. To reduce the signaling overhead, each Qpc table can be 25 differentially coded, approximated with piece-wise linear function, run-length coded, coded with Lempel-Ziv-Welch (LZW) or similar algorithms, or coded with a mixture of the abovementioned techniques. The Qpc table described above may be used for HDR content using HLG or PQ transfer characteristic. Referring back to Figs. 1-2, it is observed from Tables (100,200), and Qpc tables 30 designed for other content types such as HLG, that some Qpc values are either equal to qPi, or can be derived directly by subtracting a constant value. In order to save coding bits, the range 2024202536   17 Apr 2024 of table elements which need to be signaled in the bitstream can be specified with starting and ending indexes [startID, endID], In what follows, various methods according to the teachings of the disclosure and for signaling chroma QP values will be described. Throughout the present disclosure, the term “delta Qp, 5 also represented as “dQp”, will be used to describe the difference between two consecutive QP values. Method la In this method, the difference between two adjacent Qpc entries within [startID, endID] is coded: 10 dQpc[i] = Qpc[i] - Qpc[i-1]             (1) In general, SDR and HDR Qpc tables according to the teachings of the present disclosure may only include dQp values of 0 and 1. It is possible to signal the delta QP values directly. 15 Alternatively, codewords can be composed of multiple delta QP values. For example, delta QP values of Cb and Cr pairs having the same index value may be combined. As another example, delta QP values of two sequential index values can be combined for Cb and similarly for Cr. Optionally, sequences of codewords constructed from combinations of delta QP values can further be compressed using methods such as Huffman coding or other lossless compression 20 algorithms. For delta QPc values other than 0 and 1, a maximum delta value may be specified in syntax. In some cases, startID and endID may be constrained to be even or odd values to reduce the number of bits that would need to be signaled. The following descriptions of further embodiments will focus on the differences between it and the previously described embodiment. Therefore, features which are common to both 25 embodiments will be omitted from the following description, and so it should be assumed that features of the previously described embodiment are or at least can be implemented in the further embodiment, unless the following description thereof requires otherwise. Method lb In this method, the difference value between each pair of {qPi, Qpc} within [startID, endID] 30 may be coded: 2024202536   17 Apr 2024 dQp[i] = qPi[i] - Qpc[i] (2) The delta QP values between qPi and Qpc may be within a range from 0 to 18. This indicates that method la may be more coding friendly than method lb. Method 1c 5 This method is based on fitting the Qpc mapping curve from qPi through a piecewise-linear function defined as: Qpc[i] = qPi round (a * qPi -I- f) qPi — offset i < startID i G [startID, endID] i > endID ,          Qpc\endID\-Qpc\startID\ where a = —-——--------, qPi[endID]-qPi[startID] Qpc[startID]*qPi[endID]-Qpc[endID]*qPi[startID] qPi[endID]-qPi[startID] 10 Method Id In this method, run-length coding may be used to code the dQpc[i] values defined in formula (1). Referring to Table (100) of Fig. 1, as an example, the delta Qp values are derived as a series of 0 and 1. Delta values (0 or 1) along with the count of consequent values may be coded. Fig. 3 shows a table (300) which is an exemplary illustration of a Qpc table based on this 15 method. In accordance with an embodiment of the present disclosure, one default Qpc table may be predefined for each of different signal types such as SDR, PQ and HLG content. Figs. 4A-4B shows tables (400A, 400B) representing exemplary Qpc tables for HDR PQ and HLG content respectively. If the user-defined Qpc table is not present, the encoder and decoder may apply 20 the default Qpc table instead. Embodiments according to the present disclosure may be envisaged wherein user-defined Qpc are not signalled. This approach has the benefit of saving more bits. The following table corresponds to method la above, showing an exemplary syntax of raw byte sequence payload (RBSB) for an SPS and Tile Group header, where the syntax elements in 25 accordance with the teachings of the present disclosure are depicted in an italic font in contrast with other existing syntax elements. This is followed by detailed description of various syntax elements. A default QPc table may be specified in SPS by signalling a default Qpc table type 2024202536   17 Apr 2024 index. If the default table is not provided, the pre-defined Qpc table may be sent in SPS with delta QP values between two adjacent table elements. One or more alternative QPc tables for use in a slice may be signalled in PPS to override the SPS Qpc table. seq_parameter_set_rbsp() { Descriptor spsdecodingparametersetid u(4) ...... sps default qpc table flag ufl) iff sps default qpc tablef lag) { default qpc table type idx u(2) } else { sps separate qpc table enable flag ufl) sps qpc table start index div2 u(5) sps qpc table end index div2 u(5) forf i = sps_qpcJable_start_index_div2*2; i<= sps qpc Jable _endindex div2*2; z++ ) { sps cb qp deltafi] ufl) } iff sps separate qpc table enable flag) { forf i = sps qpc table start index_div2*2; i<= sps_qpctable end index div2*2; z++ ) { sps cr qp deltafi] ufl) } } } ...... } pic_parameter_set_rbsp() { Descriptor ppspicparametersetid ue(v) pps seq parameter set id ue(v) ...... init_qp_minus26 se(v) cu qp delta enabled flag u(l) if( cu_qp_delta_enabled_flag) cuqpdeltasubdiv ue(v) ppscbqpoffset se(v) ppscrqpoffset se(v) pps_slice_chroma_qp_offsets_present_flag u(l) ifflsps default qpc table flag) { pps slice qpc table_presentJlag ufl) } } 2024202536   17 Apr 2024 slice_header() { Descriptor slice_pic_parameter_set_id ue(v) ...... sliceqpdelta se(v) if( pps_slice_chroma_qp_offsets_present_flag ) { slicecbqpoffset se(v) slicecrqpoffset se(v) } iff pps slice qpc table present flap, ) { forfi = spsjqpcjable_start_index_div2*2; i <= sps_qpc_table_endindex div2*2; z+ + ) { slice cb qp deltafi] u(l) } iff sps separate qpc table enable flap) { forfi = sps qpc table start index_div2*2; i <= sps_qpc_table_endindex div2*2; z++ ) { slice cr qp deltafi] u(l) } } } } sps_default_qpc_table_flag equal to 1 specifies that a default chroma quantization parameter table shall be used and thus there is no need to send the Qpc table. Instead, an index is signaled to indicate which default Qpc table is to be used. 5 spsdefaultqpctableflag equal to 0 specifies that default Qpc tables have not been defined and need to be sent in SPS. default_qpc_table_type_idx indicates which default Qpc table to use when sps default qpc table flag equal to 1. defaultqpctabletypeidx equal to 0 and 10 pps_slice_qpc_table_present_flag equal to 0 indicates that one or more default SDR Qpc tables shall be used. defaultqpctabletypeidx equal to 1 and pps_slice_qpc_table_present_flag equal to 0 indicates that one or more HDR PQ Qpc tables shall be used, default qpc table type idx equal to 2 and pps_slice_qpc_table_present_flag equal to 0 indicates that one or more default HLG Qpc tables shall be used. 15 default qpc table type idx equal to 3 is reserved for future use. 2024202536   17 Apr 2024 sps_separate_qpc_table_enable_flag equal to 1 specifies that Cb and Cr use separate Qpc tables. sps_cr_qp_delta[i] and spscrqpgapidx are defined and signaled in SPS, slice_cr_qp_delta[i] and slicecrqpgapidx are defined in slice header, sps separate qpc table enable flag equal to 0 specifies that Cb and Cr use the same Qpc 5 table. sps_qpc_table_start_index_div2 specifies the starting index from which the Qpc table elements should be signaled with the delta QP values. It is defined as an even number between 0   to 63. For table elements with index less than 0 sps_qpc_table_start_index_div2*2, Qpc is set to be same as qPi. sps_qpc_table_end_index_div2 specifies the ending index before which the Qpc table elements should be signaled with the delta QP values. It is defined as an even number between 0   to 63. For table   elements with index greater than 15 sps_qpc_table_end_index_div2*2, sps_cb_qp_delta[i] and sps_cr_qp_delta[i] are set to 1. sps_cb_qp_delta[i] specifies the delta values between spsQpcb[i] and spsQpcb[i-l], with sps_cb_qp_delta[O], to construct the quantization parameter table for Cb defined in SPS. The ith entry of the Cb quantization parameter table in SPS is derived as: spsQpcb[i] = 20 sps_cb_qp_delta[i] + spsQpcb[i-l]. sps_cr_qp_delta[i] specifies the delta values between spsQpcr[i] and spsQpcr[i-l], with sps_cr_qp_delta[O], to construct the quantization parameter table for Cr defined in SPS. The ith entry of the Cr quantization parameter table in SPS is derived as: spsQpcr[i] = 25 sps_cr_qp_delta[i] + spsQpcr[i-l], pps_slice_qpc_table_present_flag equal to 1 specifies that quantization parameter tables for Cb and Cr components for the current slice are present and defined in slice header. pps_slice_qpc_table_present_flag equal to 0 specifies that quantization parameter tables 30 for Cb and Cr components for the current slice are not present in slice header and default quantization parameter tables are applied for Cb and Cr. slice_cb_qp_delta[i] specifies the delta values between sliceQpcb[i] and sliceQpcb[i-l], with slice_cb_qp_delta[0], to construct the slice quantization parameter table for Cb. The 2024202536   17 Apr 2024 ith entry of the slice Qpc table for Cb component is derived as: sliceQpcb[i] = slice_cb_qp_delta[i] + sliceQpcb[i-l]. slice_cr_qp_delta[i] is defined when spsseparateqpctableenableflag equal to 1 5 specifing the delta values between sliceQpcr[i] and sliceQpcr[i-l], with slice_cr_qp_delta[O], to construct the slice quantization parameter table for Cr. The ith entry of the slice Qpc table for Cr component is derived as: sliceQpcr[i] = slice_cr_qp_delta[i] + sliceQpcr[i-l], 0 2. Deriving the chroma QP independently from the luma QP According to further embodiments of the present disclosure, luma and chroma Qps may be signaled independently. Such an approach has the benefit of eliminating the dependency of the chroma QP on the luma QP. In what follows, derivation of the chroma QP in accordance with 15 embodiments of the present disclosure is described in detail, The initial values of the chroma quantization parameter for the slice, SliceQpCb and SliceQpCr, may be derived as follows: SliceQpCb = 26 + init_qp_minus26 + slicecbqpdelta   (3) SliceQpCr = 26 + init_qp_minus26 + slicecrqpdelta    (4) 20 qPcb prev and qPcr prev are set equal to SliceQpcb and SliceQpcr respectively if the current quantization group is the first quantization group in a slice or brick. Otherwise, qPcb prev and qPcr prev are set equal to the chroma quantization parameter Qpc of the last chroma coding unit in the previous quantization group in decoding order. qPcb pred and qPcr pred are the predicted chroma quantization parameters for current coding 25 unit. If the current quantization group is the first quantization group in a CTB row within a brick and the top coding unit is available, set qPcb pred and qPcr pred to be Qpc of the top CU, otherwise, qPcb pred = ( qPcb a + qPcb b + 1 ) » 1   (5) qPcr PRED = ( qPcr A + qPCr B + 1 ) » 1    (6) 2024202536   17 Apr 2024 where qPcb a and qP& a are set to be qPcb prev and qP& prev respectively if the left coding block is not the first coding block in the left quantization group or if the left coding block is not available; qPcb b and qP& b are set to be qPcb prev and qP& prev respectively if the top coding block is not the first coding block in the top quantization group or if the top coding 5 block is not available. The variable QpCb and QpCr for each coding unit may be derived as follows: QpCb = (( qPCbPRED + CuCbQpDeltaVal + 64 + 2 * QpBdOffsetC )%( 64 + QpBdOffsetC )) - QpBdOffsetC          (7) QpCr = (( qPCrPRED + CuCrQpDeltaVal + 64 + 2 * QpBdOffsetC )%( 64 + QpBdOffsetC 0   ))- QpBdOffsetC          (8) The chroma quantization parameter Qp'cb and Qp'( r are then derived as follows: Qp'cb = Qpcb + QpBdOffsetC (9) Qp'cr = Qpcr + QpBdOffsetC (10) The difference values between the quantization parameter of the current coding unit and its 15 prediction, CuCbQpDeltaVal and CuCrQpDeltaVal, may be specified at the transform unit layer. There are several ways to code the delta QP values: In what follows, exemplary methods in accordance with the teaching of the present disclosure will be described. Also, the difference between the QP of each color component (e.g., luma, chroma Cb, and chromo Cr) and a predicted value of the same is abbreviated as dPQ’ to 20 distinguish from dPQ which indicates, as described previously, the difference of consecutive QPs in the context of Qpc tables. Method 2a In this method, the dQP’s of the three color components, luma, chroma Cb and chroma Cr, as represented by the variables CuQpDeltaVal, CuCbQpDeltaVal and CuCrQpDeltaVal 25 respectively, are coded. The following descriptions of further embodiments will focus on the differences between it and the previously described embodiment. Therefore, features which are common to both 2024202536   17 Apr 2024 embodiments will be omitted from the following description, and so it should be assumed that features of the previously described embodiment are or at least can be implemented in the further embodiment, unless the following description thereof requires otherwise. Method 2b 5 In this method, the dQP’ of the luma component, CuQpDeltaVal is coded. Additionally, the difference between the dQp’ of each chroma component with the luma dQp’ is coded according to the following: CbdQpDeltaVal = CuCbQpDeltaVal - CuQpDeltaVal (11) CrdQpDeltaVal = CuCrQpDeltaVal - CuQpDeltaVal (12) 10 Method 2c In this method, the element CrCbdQpDeltaVal as defined below CrCbdQpDeltaVal = CuCrQpDeltaVal - CuCbQpDeltaVal (13) is coded, wherein elements CuCrQpDeltaVal and CuCbQpDeltaVal have the same definition 15 as in the case of Method 2c described above. Method 2d In this method, the element CrCbdQpDeltaVal as defined below CrCbdQpDeltaVal = CuCrQpDeltaVal - CuCbQpDeltaVal (13) 20 is coded, wherein elements CuCrQpDeltaVal and CuCbQpDeltaVal have the same definition as in the case of Method 2c described above. Method 2e In this method, difference values from chroma QP and luma QP, defined as dQp'cb = Qp'y - Qp'cb (14) 25                              dQp'& = Qp'y - Qp'cr (15) 2024202536   17 Apr 2024 are coded. Signaling for Method 2e is similar as Method 2a, without requiring to signal slice cb qp delta and slicecrqpdelta (see below) in the slice header. The following table corresponds to method 2a above, showing an exemplary syntax of raw byte 5 sequence payload (RBSB) for an SPS and Tile Group header, where the syntax elements in accordance with the teachings of the present disclosure are depicted in italics in contrast with other existing syntax elements. This is followed by detailed description of various syntax elements. pic_parameter_set_rbsp() { Descriptor ppspicparametersetid ue(v) pps seq parameter set id ue(v) ...... init_qp_minus26 se(v) cu qp delta enabled flag u(l) if( cu_qp_delta_enabled_flag ) cuqpdeltasubdiv ue(v) cu chroma qp delta enabledJlag u(l) ...... } slice_header() { Descriptor slicepicparametersetid ue(v) ...... sliceqpdelta se(v) iff cu chroma qp delta enabled flag) { slice cb qp delta sefv) slice cr qp delta sefv) } } 2024202536   17 Apr 2024 transform_unit( xO, yO, tbWidth, tbHeight, treeType, subTuIndex ) { Descriptor ...... if( (tu_cbf_luma[ xO ][ yO ] 11 tu_cbf_cb[ xO ][ yO ] 11 tu_cbf_cr[ xO ][ yO ]) && treeType != DUAL TREE CHROMA ) { if( cu_qp_delta_enabled_flag     &&     tucbflumaf xO ][yO ]     && !IsCuQpDeltaCoded ) { cuqpdeltaabs ae(v) if( cu qp delta abs ) cuqpdeltasign flag ae(v) if(cu_chroma_qp_delta_enabledJlag && tu_cbf_cb[xO][yO ] && IbsCuCbQpDeltaCoded) { cu cb qp delta abs ae(v) if( cu cb qp delta abs) cu cb qp delta sign flag ae(v) } if( cu_chroma_qp_delta_enabledJlag && tu_cbf_cr[xO][yO] && UsCuCrQpDeltaCoded) { cu cr qp delta abs ae(v) if( cu cr qp delta abs) __________cu cr_ qp delta sign^lag_______________________________________ } ae(v) ...... } dual_tree_implicit_qt_split( xO, yO, cbSize, cqtDepth ) { Descriptor cbSubdiv = 2 * cqtDepth if( cbSize > 64 ) { if( cu qp delta enabled flag && cbSubdiv <= cu qp delta subdiv ) { IsCuQpDeltaCoded = 0 CuQpDeltaVal = 0 CuQgTopLeftX = xO CuQgTopLeftY = yO } if( cu chroma qp_deltaenabledJlag && cbSubdiv <= cu qp delta sub div) { IsCuCbQpDeltaCoded= 0 IsCuCrQpDeltaCoded = 0 CuCbQpDeltaVal = 0 CuCrQpDeltaVal = 0 } 2024202536   17 Apr 2024 ...... } else { coding_tree( xO, yO, cbSize, cbSize, 1, cbSubdiv, cqtDepth, 0, 0, 0, DUALTREELUMA) coding_tree( xO, yO, cbSize, cbSize, 0, cbSubdiv, cqtDepth, 0, 0, 0, DUAL TREE CHROMA ) } } coding_tree( xO, yO, cbWidth, cbHeight, qgOn, cbSubdiv, cqtDepth, mttDepth, depthO ffset, partldx, treeType ) { Descriptor ...... if( cu qp delta enabled flag && qgOn && cbSubdiv <= cu qp delta subdiv) IsCuQpDeltaCoded = 0 CuQpDeltaVal = 0 CuQgTopLeftX = xO CuQgTopLeftY = yO } z / f cu_chroma_qp_delta_enabledjlag && qgOn && cbSubdiv <= cu qp delta sub div) { IsCuCbQpDeltaCoded = 0 IsCuCrQpDeltaCoded = 0 CuCbQpDeltaVal = 0 CuCrQpDeltaVal= 0 } ...... } The methods and systems described in the present disclosure may be implemented in hardware, software, firmware or any combination thereof. Features described as blocks, modules or 5 components may be implemented together (e.g., in a logic device such as an integrated logic device) or separately (e.g., as separate connected logic devices). The software portion of the methods of the present disclosure may comprise a computer-readable medium which comprises instructions that, when executed, perform, at least in part, the described methods. The computer-readable medium may comprise, for example, a random-access memory (RAM) 10 and / or a read-only memory (ROM). The instructions may be executed by a processor (e.g., a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field 2024202536   17 Apr 2024 programmable logic array (FPGA), a graphic processing unit (GPU) or a general-purpose GPU). A number of embodiments of the disclosure have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope 5 of the present disclosure. Accordingly, other embodiments are within the scope of the following claims. The examples set forth above are provided to those of ordinary skill in the art as a complete disclosure and description of how to make and use the embodiments of the disclosure and are not intended to limit the scope of what the inventor / inventors regard as their disclosure. 0 Modifications of the above-described modes for carrying out the methods and systems herein disclosed that are obvious to persons of skill in the art are intended to be within the scope of the following claims. All patents and publications mentioned in the specification are indicative of the levels of skill of those skilled in the art to which the disclosure pertains. All references cited in this disclosure are incorporated by reference to the same extent as if each reference had 15 been incorporated by reference in its entirety individually. It is to be understood that the disclosure is not limited to particular methods or systems, which can, of course, vary. It is also to be understood that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting. As used in this specification and the appended claims, the singular forms "a," "an," and "the" include 20 plural referents unless the content clearly dictates otherwise. The term “plurality” includes two or more referents unless the content clearly dictates otherwise. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the disclosure pertains.

Claims

1. A method to reconstruct coded data with one or more processors, the method comprising: receiving a coded bitstream comprising one or more coded pictures, wherein each 5 picture comprises a luminance component, a first chroma component, and a second chroma component;extracting syntax parameters from the coded bitstream to determine a chroma quantization parameter (QP) table; anddecoding the one or more coded pictures based on the chroma QP table, wherein the0 syntax parameters comprise a start luminance QP value and one or more offset parameters to determine a mapping of the luminance QP values to the chroma QP values using a piece-wise linear representation.

2. The method of claim 1, wherein the one or more offset parameters comprise a delta QP15 chroma parameter dQpc[i] = Qpc[i] - Qpc[i-1], wherein i denotes an index and Qpc[i-1 ] and Qpc[i] denote consecutive chroma QP values.

3. The method of claim 1, wherein the syntax parameters further comprise a flag indicating whether the first chroma component and the second chroma component share a common20 chroma QP table or whether the first chroma component and the second chroma component have different chroma QP tables.

4. A method to encode a sequence of video pictures to generate a coded video bitstream, the method comprising:25          receiving a sequence of pictures wherein each picture comprises a luminancecomponent, a first chroma component, and a second chroma component;encoding the sequence of video pictures using luminance quantization parameters (QP) values and chroma QP values to generate a coded video bitstream; andencoding signal parameters in the coded video bitstream for a decoder to determine a30 chroma QP table, wherein the signal parameters comprise a start luminance QP value and one or more offset parameters to determine a mapping of the luminance QP values to the chroma QP values using a piece-wise linear representation.2024202536   17 Apr 20245. The method of claim 4, wherein the one or more offset parameters comprise a delta QP chroma parameter dQpc[i] = Qpc[i] - Qpc[i-1], wherein i denotes an index and Qpc[i-1 ] and Qpc[i] denote consecutive chroma QP values.5   6. The method of claim 4, wherein the signal parameters further comprise a flag indicatingwhether the first chroma component and the second chroma component share a common chroma QP table or whether the first chroma component and the second chroma component have different chroma QP tables.

Images