High-precision transforms and quantization for image and video encoding and decoding

Abstract

Methods, systems, and apparatus for high precision transform and quantization for image and video coding and decoding are described. An example method of video processing includes: for conversion between a video including a current block and a bitstream representation of the video, determining that the conversion includes application of a transform to the current block, and performing the conversion based on the determination, wherein a bit shifting operation of a scaling process of transform coefficients associated with the transform is based on whether the current block is encoded or decoded using a block-based differential pulse codec modulation (BDPCM) mode.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application is filed in order to timely claim the priority and benefits of International Patent Application No. PCT / CN2019 / 107140 filed on September 21, 2019, in accordance with applicable patent laws and / or the Paris Convention. For all legal purposes, the entire disclosure of the above application is incorporated by reference as part of the disclosure of this application. Technical Field

[0003] This patent document relates to video encoding and decoding. Background Art

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

[0005] Apparatus, systems and methods relate to digital video coding and decoding, and in particular to encoding and decoding of videos and images using high precision transforms and quantization.

[0006] In one example aspect, a video processing method is disclosed. The method includes: performing conversion between a current block of video and a bitstream representation of the video according to a rule, wherein the rule specifies that a scaling operation of a transform codec mode applied to the current block is configured to be independent of a size of the current block.

[0007] In another example aspect, a video processing method is disclosed. The method includes: performing conversion between a current block of a video and a bitstream representation of the video according to a rule, wherein the rule specifies that a dequantization process or a scaling operation of a transform codec mode applied to the current block is configured to be independent of the transform codec mode.

[0008] In yet another example aspect, a video processing method is disclosed. The method includes: for conversion between a video including a current block and a bitstream representation of the video, determining that the conversion includes application of a transform to the current block, and performing the conversion based on the determination, wherein a bit shifting operation of a scaling process of transform coefficients associated with the transform is based on whether the current block is encoded using a block-based differential pulse codec modulation (BDPCM) mode.

[0009] In yet another example aspect, a video processing method is disclosed. The method includes performing conversion between a video including a current block and a bitstream representation of the video, wherein a transform shift used when converting between residual coefficient values ​​of the current block and codec coefficients of the current block is based on whether the current block is coded in a block-based differential pulse codec modulation (BDPCM) mode.

[0010] In yet another example aspect, a video processing method is disclosed. The method includes: for conversion between a video including a current block and a bitstream representation of the video, determining that the current block is encoded using a block-based differential pulse codec modulation (BDPCM) mode, and performing the conversion based on the determination, wherein a scaling list associated with the BDPCM mode is disabled.

[0011] In yet another example aspect, a video processing method is disclosed. The method includes: for conversion between a video including a current block and a bitstream representation of the video, determining that the conversion is performed by disabling application of a transform to the current block, and performing the conversion based on the determination, wherein the conversion includes a dequantization process, and wherein after the dequantization process, the decoded coefficients are constrained to a range having a minimum value (TxMin) and a maximum value (TsMax).

[0012] In yet another example aspect, a video processing method is disclosed. The method includes: for conversion between a video including a current block and a bitstream representation of the video, determining that the current block is encoded using a block-based differential pulse codec modulation (BDPCM) mode, and performing conversion based on the determination, wherein the conversion includes a dequantization process, and wherein after the dequantization process, the decoded coefficients are constrained to a first range having a minimum value (BdpcmMin) and a maximum value (BdpcmMax).

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

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

[0015] In yet another aspect, a video decoder device may implement the methods described herein.

[0016] The above and other aspects and features of the disclosed technology will be described in more detail in the drawings, the specification and the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] Figure 1 An example of a low frequency non-separable transform (LFNST) process is shown.

[0018] Figure 2 Examples of SBT positions, types, and transformation types are shown.

[0019] Figure 3 is a schematic diagram of two scalar quantizers used in the proposed slave quantization method.

[0020] Figure 4 Examples of state transitions and quantizer selection for the proposed slave quantization are shown.

[0021] Figure 5 is a block diagram of an example video processing system in which the disclosed techniques may be implemented.

[0022] Figure 6 is a block diagram of an example hardware platform for video processing.

[0023] Figure 7-Figure 13 is a flow chart of an example method of video processing. DETAILED DESCRIPTION

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

[0025] 1 Video Codec Overview

[0026] This document relates to image and video codec technology. Specifically, it relates to transforms, dequantization, and inverse transforms in image and video codecs. It can be applied to existing video codec standards such as HEVC or to standards to be finalized (universal video codec). It can also be applied to future video standards or video encoders.

[0027] 2 Preliminary Discussion

[0028] Video codec standards have evolved primarily through the development of the well-known ITU-T and ISO / IEC standards. ITU-T produced the H.261 and H.263 standards, ISO / IEC produced the MPEG-1 and MPEG-4 Visual standards, and the two organizations jointly produced the H.262 / MPEG-2 Video standard and the H.264 / MPEG-4 Advanced Video Coding (AVC) standard and the H.265 / HEVC standard. Starting with H.262, video codec standards are based on a hybrid video codec structure that utilizes temporal prediction plus transform coding. In order to explore future video codec technologies beyond HEVC, the Joint Video Exploration Team (JVET) was jointly established by VCEG and MPEG 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 Team (JVET) between VCEG (Q6 / 16) and ISO / IEC JTC1 SC29 / WG11 (MPEG) was established to work on the VVC standard with the goal of reducing bitrate by 50% compared to HEVC.

[0029] 2.1 Transformation and Quantization

[0030] 2.1.1 Large Block Size Transformation with High Frequency Zeroing

[0031] In VTM5, large block size transforms are enabled, up to 64×64 in size, which are mainly used for higher resolution video, such as 1080p and 4K sequences. For transform blocks with a size (width or height, or both) equal to 64, the high-frequency transform coefficients are zeroed so that only low-frequency coefficients are retained. For example, for an M×N transform block, where M is the block width and N is the block height, when M is equal to 64, only the left 32 columns of transform coefficients are retained. Similarly, when N is equal to 64, only the top 32 rows of transform coefficients are retained. When transform skip mode is used for large blocks, the entire block is used without zeroing any values.

[0032] 2.1.2 Multiple Transform Selection (MTS) for Core Transformations

[0033] In addition to the DCT-II already adopted in HEVC, a multiple transform selection (MTS) scheme is used to perform residual coding for both inter-frame and intra-frame coding blocks. This scheme uses multiple transforms selected from DCT8 / DST7. The newly introduced transform matrices are DST-VII and DCT-VIII. Table 1 shows the basis functions of the selected DST / DCT.

[0034] Table 1 - Transform basis functions of DCT-II / VIII and DSTVII for N-point input

[0035]

[0036] To maintain the orthogonality of the transform matrix, the transform matrix is ​​quantized more accurately than the transform matrix in HEVC. To keep the intermediate values ​​of the transform coefficients within the 16-bit range, all coefficients have 10 bits after horizontal and vertical transforms.

[0037] To control the MTS scheme, separate enable flags are specified at the SPS level for intra and inter frames respectively. When MTS is enabled at the SPS, a CU-level flag is signaled to indicate whether MTS is applied. Here, MTS is applied only to luma. The MTS CU-level flag is signaled when the following conditions are met.

[0038] - Both width and height are less than or equal to 32

[0039] -CBF flag equals one

[0040] If the MTS CU flag is equal to zero, DCT2 is applied in both directions. However, if the MTS CU flag is equal to one, the other two flags are additionally signaled to indicate the transform types in the horizontal and vertical directions, respectively. The transform and signaling mapping table is shown in Table 2. By removing the dependency on intra mode and block shape, a transform selection unified for ISP and implicit MTS is used. If the current block is in ISP mode or if the current block is an intra block and the intra and inter explicit MTS are turned on, only DST7 is used for both horizontal and vertical transform cores. When it comes to transform matrix precision, an 8-bit main transform core is used. Therefore, all transform cores used in HEVC remain the same, including 4-point DCT-2 and DST-7, 8-point, 16-point and 32-point DCT-2. Similarly, other transform cores including 64-point DCT-2, 4-point DCT-8, 8-point, 16-point, 32-point DST-7 and DCT-8 use 8-bit main transform cores.

[0041] Table 2 - Transformation and signaling mapping table

[0042]

[0043] To reduce the complexity of large-size DST-7 and DCT-8, high-frequency transform coefficients are zeroed for DST-7 and DCT-8 blocks with size (width or height, or both) equal to 32. Only coefficients in the 16x16 low-frequency region are retained.

[0044] As in HEVC, the residual of a block can be coded with transform skip mode. To avoid redundancy in syntax coding, the transform skip flag is not signaled when the CU-level MTS_CU_flag is not equal to zero. The block size limit for transform skip is the same as that for MTS in JEM4, which indicates that transform skip is applicable to CUs when both block width and height are equal to or less than 32.

[0045] 2.1.3 Transform coefficients reset to zero

[0046] When the transform unit is large, a large transform kernel may be required, which brings much greater complexity compared to small transforms. Therefore, in the current VVC design, when the transform unit is large enough, a certain part of the transform coefficients will be set to 0 to reduce the required transform size.

[0047] Specifically, in the current VVC draft, two variables are defined to reflect which part of the coefficient will be kept:

[0048] nonZeroW=Min(nTbW, (trTypeHor>0)?16:32) nonZeroH=Min(nTbH, (trTypeVer>0)?16:32)

[0049] Therefore, after the 2D forward transform, only the cases x=0..nonZeroW-1 and y=0..nonZeroH-1 may contain non-zero coefficients and all other coefficients are set to zero.

[0050] We denote nonZeroW and nonZeroH as the actual transform sizes of width and height, which may be different from the width (nTbW) and height (nTbH) of the transform unit.

[0051] 2.1.4 Low-Frequency Non-Separable Transform (LFNST)

[0052] In VTM5, LFNST (Low Frequency Non-separable Transform) called Reduced Secondary Transform is applied between the forward main transform and quantization (at the encoder) and between dequantization and inverse main transform (at the decoder side), as shown in Figure 1 As shown in FIG. 4 , in LFNST, a 4x4 non-separable transform or an 8x8 non-separable transform is applied depending on the block size. For example, 4x4 LFNST is applied to small blocks (i.e., min(width, height) < 8) and 8x8 LFNST is applied to larger blocks (i.e., min(width, height) > 4).

[0053] Figure 1 An example of a low frequency non-separable transform (LFNST) process is shown.

[0054] The application of the non-separable transform being used in LFNST is described as follows using the input as an example. To apply 4x4 LFNST, the 4x4 input block X

[0055]

[0056] First, we represent it as a vector

[0057]

[0058] Compute the inseparable transformation as in Indicates the transform coefficient vector and the 16x16 transform matrix. Using a 4x4 block scan order (horizontally, vertically or diagonally), the 16x1 coefficient vector Then reorganize into this 4x4 block. Coefficients with smaller indices will be placed in the 4x4 coefficient block with smaller scan indices.

[0059] 2.1.4.1 Reduction of Inseparable Transformations

[0060] LFNST (Low Frequency Non-separable Transform) is based on a direct matrix multiplication method to apply a non-separable transform so that the transform is implemented in a single pass without multiple iterations. However, the non-separable transform matrix dimensions need to be reduced to minimize the computational complexity and memory space for storing the transform coefficients. Therefore, the Reduced Non-separable Transform (or RST) method is used in LFNST. The main idea of ​​the Reduced Non-separable Transform is to map an N (for 8x8 NSST, N is usually equal to 64) dimensional vector to an R dimensional vector in a different space, where N / R (R<N) is the reduction factor. Therefore, in addition to the NxN matrix, the RST matrix becomes an R×N matrix as follows:

[0061]

[0062] Wherein the R row of transformation is the R basis of N-dimensional space. The inverse transformation matrix of RT is the transpose of the forward transformation. For 8x8 LFNST, a reduction factor of 4 is applied in VTM5, and the 64x64 direct matrix (which is the size of the conventional 8x8 indivisible transformation matrix) is reduced to a 16x48 direct matrix. Therefore, a 48×16 inverse RST matrix is ​​used at the decoder side to generate core (one-time) transform coefficients in the 8×8 upper left region. When the 16x48 matrix is ​​applied in the same transform set configuration instead of the 16x64, each 16x48 matrix obtains 48 input data from three 4x4 blocks in the upper left 8x8 block excluding the upper right 4x4 block. With the help of reduced dimensionality, the memory usage for storing all LFNST matrices is reduced from 10KB to 8KB with reasonable performance degradation. To further reduce the worst case complexity in terms of multiplication count when all TUs are composed of 4x4 TUs or 8x8 TUs, the top 8x48 and 8x16 matrices are applied to 8x8 TUs and 4x4 TUs, respectively. For blocks larger than 8x8 TUs, the worst case does not occur so that 8x8 LFNST (i.e., 16x48 matrix) is applied to the upper left 8x8 region. For 8x4 TUs or 4x8 TUs, only 4x4 LFNST (i.e., 16x16 matrix) is applied to the upper left 4x4 region. For 4xN or Nx4 TUs (N≥16), 4x4 LFNST is applied to each of the two adjacent upper left 4x4 blocks. With the above simplifications, the worst case number of multiplications becomes 8 per sample point.

[0063] 2.1.4.2 LFNST Transform Selection

[0064] In LFNST, a total of 4 transform sets are used, and 2 inseparable transform matrices (kernels) per transform set. As shown in Table 3, the mapping from intra prediction modes to transform sets is predefined. For each transform set, the selected inseparable secondary transform candidate is further specified by the LFNST index explicitly signaled. This index is signaled once per intra CU in the bitstream after the transform coefficients.

[0065] Table 3 Transformation selection table

[0066] IntraPredMode Transform Settings Index IntraPredMode<0 1 0<=IntraPredMode<=1 0 2<=IntraPredMode<=12 1 13<=IntraPredMode<=23 2 24<=IntraPredMode<=44 3 45<=IntraPredMode<=55 2 56<=IntraPredMode 1

[0067] 2.1.4.3 LFNST index signaling and interaction with other tools

[0068] Forward 8x8 LFNST uses a 16×48 matrix so that forward 8x8 LFNST produces non-zero coefficients only in the upper left 4×4 region within a given 8×8 region. In other words, if LFNST is applied, only zero coefficients are generated in the 8×8 region other than the upper left 4×4 region. Therefore, the LFNST index is not decoded when non-zero elements are detected in the 8x8 block region other than the upper left 4×4, because this implies that LFNST is not applied. In such a case, the LFNST index is inferred to be zero. If the LFNST index is equal to 0, LFNST is not applied. Otherwise, LFNST is applied. In addition, the LFNST index is context-decoded but does not depend on the intra prediction mode, and only the first binary number is context-decoded.

[0069] The inverse LFNST is conditionally applied when the following two conditions are met:

[0070] a. The block size is greater than or equal to the given threshold (W>=4&&H>=4)

[0071] b. Transform skip mode flag equals zero

[0072] If both the width (W) and height (H) of the transform coefficient block are greater than 4, the 8x8 LFNST is applied to the upper left 8x8 region of the transform coefficient block. Otherwise, the 4x4 LFNST is applied on the upper left min(8, W)×min(8, H) region of the transform coefficient block.

[0073] In addition, LFNST is applied to intra CUs in both intra and inter slices, and to both luma and chroma. If dual tree is enabled, LFNST indexes for luma and chroma are signaled separately. For inter slices (dual tree disabled), a single LFNST index is signaled and used for both luma and chroma.

[0074] When ISP mode is selected, LFNST is disabled and the RST index is not signaled, because even if RST is applied to every feasible partition, the performance improvement is negligible. In addition, disabling RST for the residual of ISP prediction can reduce coding complexity. When MIP mode is selected, LFNST is also disabled and the index is not signaled.

[0075] 2.1.5 Sub-Block Transform (SBT)

[0076] In VTM, sub-block transform is introduced for inter-predicted CUs. In this transform mode, only a sub-part of the residual block is encoded and decoded for the CU. When there is an inter-predicted CU with cu_cbf equal to 1, cu_sbt_flag can be signaled to indicate whether to encode the entire residual block or a sub-part of the residual block. In the former case, the inter-MTS information is further parsed to determine the transform type of the CU. In the latter case, a part of the residual block is encoded and decoded with the inferred adaptive transform and the other parts of the residual block are zeroed.

[0077] When SBT is used for inter-frame coded CU, the SBT type and SBT location information are signaled in the bitstream. Figure 2 As shown, there are two SBT types and two SBT positions. For SBT-V (or SBT-H), the TU width (or height) can be equal to half of the CU width (or height) or 1 / 4 of the CU width (or height), resulting in 2:2 partitioning or 1:3 / 3:1 partitioning. The 2:2 partition is like a binary tree (BT) partition, while the 1:3 / 3:1 partition is like an asymmetric binary tree (ABT) partition. In the ABT partition, only small areas contain non-zero residuals. If one dimension of the CU is 8 in luminance samples, a 1:3 / 3:1 partition along that dimension is not allowed. There are up to 8 SBT modes for a CU.

[0078] Position-dependent transform core selection is applied to luma transform blocks in SBT-V and SBT-H (chroma TBs always use DCT-2). The two positions of SBT-V and SBT-H are associated with different core transforms. More specifically, Figure 2 Horizontal and vertical transforms are specified for each SBT position. For example, the horizontal transform and vertical transform of SBT-V position 0 are DCT-8 and DST-7, respectively. When one side of the residual TU is greater than 32, the transforms of both dimensions are set to DCT-2. Therefore, the sub-block transforms collectively specify the TU tiling, cbf, and horizontal and vertical core transform types of the residual block.

[0079] The variable maxSbtSize is signaled in the SPS to specify the maximum CU size to which SBT can be applied. In VTM5, the encoder sets maxSbtSize to 64 for HD and 4K sequences and to 32 for other smaller resolution sequences.

[0080] SBT does not apply to CUs coded or decoded in combined inter-intra mode or TPM mode.

[0081] 2.1.6 Quantification

[0082] In VTM5, the maximum QP is extended from 51 to 63, and the signaling of the initial QP changes accordingly. When a non-zero value of slice_qp_delta is encoded, the initial value of SliceQpY will be modified at the slice segment layer. Specifically, the value of init_qp_minus26 is modified to be in the range of (-26+QpBdOffsetY) to +37. In VTM5, when the size of the transform block is not a power of 4, the transform coefficients will be processed together with modifications to the QP or QP levelScale table instead of multiplying by 181 / 256 (or 181 / 128) to compensate for implicit scaling by the transform process.

[0083] In addition, the same HEVC scalar quantization is used by a new concept called dependent scalar quantization. Dependent scalar quantization refers to a method in which the set of allowable reconstruction values ​​of a transform coefficient depends on the value of the transform coefficient level in the reconstruction order before the current transform coefficient level. The main effect of this method is that the allowable reconstruction vectors are more densely grouped in the N-dimensional vector space (N represents the number of transform coefficients in the transform block) compared to the conventional independent scalar quantization used in HEVC. This means that for a given average number of allowable reconstruction vectors per N-dimensional unit volume, the average distortion between the input vector and the closest reconstruction vector is reduced. The method of dependent scalar quantization is implemented by: (a) defining two scalar quantizers at different reconstruction levels, and (b) defining a process of switching between the two scalar quantizers.

[0084] Figure 3 is a schematic diagram of two scalar quantizers used in the proposed slave quantization method.

[0085] Figure 3 The two scalar quantizers used, denoted by Q0 and Q1, are illustrated. The position of the available reconstruction levels is uniquely specified by the quantization step size Δ. The scalar quantizer used (Q0 or Q1) is not explicitly signaled in the bitstream. Instead, the quantizer used for the current transform coefficient is determined by the parity of the transform coefficient level in the encoding / reconstruction order that precedes the current transform coefficient.

[0086] Figure 4 Examples of state transitions and quantizer selection for the proposed slave quantization are shown.

[0087] like Figure 4As shown, the switching between the two scalar quantizers (Q0 and Q1) is implemented via a state machine with four states. The state can take four different values: 0, 1, 2, 3. This is uniquely determined by the parity of the transform coefficient level that is sorted in the encoding / reconstruction order before the current transform coefficient. At the beginning of the inverse quantization of the transform block, the state is set equal to 0. The transform coefficients are reconstructed in the scan order (i.e., they are entropy decoded in the same order). After the reconstruction of the current transform coefficient, as shown in FIG. Figure 4 The update state is shown, where k indicates the value of the transform coefficient level.

[0088] Signaling of default and user defined scaling matrices is also supported. The default mode scaling matrices are all flat with elements equal to 16 for TB size. IBC and intra codec modes currently share the same scaling matrix. Therefore, for the case of USER_DEFINED matrices, the numbers of MatrixType and MatrixType_DC are updated as follows:

[0089] MatrixType: 30 = 2 (2 for intra & IBC / inter) × 3 (Y / Cb / Cr components) × 5 (square TB size: from 4×4 to 64×64 for luma, from 2×2 to 32×32 for chroma)

[0090] MatrixType_DC: 14 = 2 (1 of 2 × Y components for intra & IBC / inter) × 3 (TB size: 16 × 16, 32 × 32, 64 × 64) + 4 (2 × Cb / Cr components for intra & IBC / inter) × 2 (TB size: 16 × 16, 32 × 32)

[0091] The DC values ​​are encoded and decoded for the following scaling matrices: 16×16, 32×32, and 64×64, respectively. For TBs of size less than 8×8, all elements in a scaling matrix are signaled. If the size of the TB is greater than or equal to 8×8, only 64 elements in an 8×8 scaling matrix are signaled as the base scaling matrix. In order to obtain a square matrix of size greater than 8×8, the 8×8 base scaling matrix is ​​upsampled (by repetition of elements) to the corresponding square size (i.e., 16×16, 32×32, 64×64). When the zeroing of the high-frequency coefficients of the 64-point transform is applied, the corresponding high frequencies of the scaling matrix are also zeroed. That is, if the width or height of the TB is greater than or equal to 32, only the left half or the upper half of the coefficients are retained, and the remaining coefficients are assigned to zero. In addition, because the lower right 4×4 elements are never used, the number of elements signaled for the 64×64 scaling matrix is ​​also reduced from 8×8 to three 4×4 sub-matrices.

[0092] 2.1.7 Joint Encoding and Decoding of Chroma Residual

[0093] VTM5 supports a mode of joint coding and decoding of chroma residuals. When this mode is activated, a single joint residual block is signaled for the Cb blocks and Cr blocks in the same transform unit. The Cb residual is then set equal to the signaled residual, and the Cr residual is set by eliminating the sign of the signaled residual. In other words, at the decoder, in order to reconstruct the chroma block, the signaled joint residual is added to the Cb prediction block and subtracted from the Cr prediction block. The joint residual is encoded and decoded using the conventional chroma residual coding and decoding process. If both the Cb and Cr codec block flags (cbf) are 1, a flag is used in the bitstream to signal a flag indicating whether the joint residual mode is used.

[0094] The chroma QP offset values ​​for joint chroma residual codec mode signaling are separated from the usual chroma QP offset values ​​for normal chroma residual codec mode signaling in the PPS and in the slice header. These chroma QP offset values ​​are used to derive the chroma QP values ​​for those blocks coded using the joint chroma residual codec mode. In the VTM5 encoder, the chroma QP offset is set to -1 for the joint chroma residual codec mode and to +1 for the normal chroma residual codec mode.

[0095] At the encoder side, the mean of the Cr residuals subtracted from the Cb residuals is used as input to the transform and quantization process:

[0096] resJoint=(resCb-resCr) / 2

[0097] If chroma scaling for the LMCS mode is active, chroma scaling is applied to the joint residual in the same way as done for the regular chroma residual codec mode. That is, the codec joint residual signal is scaled.

[0098] 2.2 Dequantization and Inverse Transform Design in VVC Draft 6

[0099] 2.2.1 Dequantization

[0100] 8.7.3 Scaling of Transform Coefficients

[0101] The inputs to this process are:

[0102] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[0103] - variable nTbW, specifies the transform block width,

[0104] - variable nTbH, specifies the transform block height,

[0105] - variable cIdx, specifies the color component of the current block,

[0106] -The variable bitDepth specifies the bit depth of the current color component.

[0107] The output of this process is a (nTbW)x(nTbH) matrix d of scaled transform coefficients with elements d[x][y].

[0108] The quantization parameter qP is derived as follows:

[0109] - If cIdx is equal to 0 and transform_skip_flag[xTbY][yTbY] is equal to 0, the following applies:

[0110] qP=Qp′ Y (8-950)

[0111] Otherwise, if cIdx is equal to 0 (and transform_skip_flag[xTbY][yTbY] is equal to 1), the following applies:

[0112] qP=Max(QpPrimeTsMin,Qp′ Y )(8-951)

[0113] Otherwise, if TuCResMode[xTbY][yTbY] is equal to 2, the following applies:

[0114] qP=Qp′ CbCr (8-952)

[0115] - Otherwise, if cIdx is equal to 1, the following applies:

[0116] qP=Qp′ Cb (8-953)

[0117] - Otherwise (cIdx equals 2), the following applies:

[0118] qP=Qp′ Cr (8-954)

[0119] The variable rectNonTsFlag is exported as follows:

[0120] rectNonTsFlag=(((Log2(nTbW)+Log2(nTbH))&1)==1&&(8-955)

[0121] transform_skip_flag[xTbY][yTbY]==0)

[0122] The variables bdShift, rectNorm, and bdOffset are derived as follows:

[0123] bdShift=bitDepth+((rectNonTsFlag?1:0)+(8-956)(Log2(nTbW)+Log2(nTbH)) / 2)-5+dep_quant_enabled_flagbdOffset=(1<<bdShift)>>1(8-957)

[0124] The list levelScale[][] is specified as levelScale[j][k] = {{40, 45, 51, 57, 64, 72}, {57, 64, 72, 80, 90, 102}}, where j = 0..1, k = 0..5.

[0125] The (nTbW)x(nTbH) matrix dz is set equal to the (nTbW)x(nTbH) matrix TransCoeffLevel[xTbY][yTbY][cIdx].

[0126] To derive the scaled transform coefficients d[x][y], where x = 0..nTbW-1, y = 0..nTbH-1, the following applies:

[0127] - The intermediate scaling factor m[x][y] is derived as follows:

[0128] - m[x][y] is set equal to 16 if one or more of the following conditions are true:

[0129] -sps_scaling_list_enabled_flag is equal to 0.

[0130] -transform_skip_flag[xTbY][yTbY] is equal to 1.

[0131] - Otherwise, the following applies:

[0132] m[x][y]=ScalingFactor[Log2(nTbW)][Log2(nTbH)][matrixId][x][y],

[0133] Where matrixId is specified as in Table 7-5 (8-958)

[0134] -The scaling factor ls[x][y] is derived as follows:

[0135] - If dep_quant_enabled_flag is equal to 1, the following applies:

[0136] ls[x][y]=(m[x][y]*levelScale[rectNonTsFlag][(qP+1)%6])<<((qP+1) / 6)(8-959)

[0137] - Otherwise (dep_quant_enabled_flag is equal to 0), the following applies:

[0138] ls[x][y]=(m[x][y]*levelScale[rectNonTsFlag][qP%6])<<(qP / 6)(8-960)

[0139] -When BdpcmFlag[xTbY][yYbY] is equal to 1, dz[x][y] is modified as follows:

[0140] - If BdpcmDir[xTbY][yYbY] is equal to 0 and x is greater than 0, the following applies:

[0141] dz[x][y]=Clip3(CoeffMin,CoeffMax,dz[x-1][y]+dz[x][y])(8-961)

[0142] Otherwise, if BdpcmDir[xTbY][yYbY] is equal to 1 and y is greater than 0, the following applies:

[0143] dz[x][y]=Clip3(CoeffMin,CoeffMax,dz[x][y-1]+dz[x][y])(8-962)

[0144] -The value dnc[x][y] is derived as follows:

[0145] dnc[x][y]=(dz[x][y]*ls[x][y]+bdOffset)>>bdShift(8-963)

[0146] -The scaling transformation coefficients d[x][y] are derived as follows:

[0147] d[x][y]=Clip3(CoeffMin, CoeffMax, dnc[x][y])(8-964)

[0148] 2.2.2 Inverse transformation

[0149] 8.7.5 Scaling Transform Coefficients Transformation Process

[0150] 8.7.5.1 General

[0151] The inputs to this process are:

[0152] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[0153] - variable nTbW, specifies the width of the current transform block,

[0154] - variable nTbH, specifies the height of the current transform block,

[0155] - variable cIdx, specifies the color component of the current block,

[0156] - A (nTbW)x(nTbH) matrix d[x][y] of scaled transform coefficients, where x=0..nTbW-1, y=0..nTbH-1.

[0157] The output of this process is a (nTbW)x(nTbH) matrix r[x][y] of residual samples, where x=0..nTbW-1, y=0..nTbH-1.

[0158] When lfnst_idx[xTbY][yTbY] is not equal to 0 and both nTbW and nTbH are greater than or equal to 4, the following applies:

[0159] - The variables predModeIntra, nLfhstOutSize, log2LfnstSize, nLfhstSize, and nonZeroSize are derived as follows:

[0160] predModeIntra=(cIdx==0)? IntraPredModeY[xTbY][yTbY]:IntraPredModeC[xTb Y][yTbY](8-965)

[0161] nLfnstOutSize=(nTbW>=8&&nTbH>=8)? 48:16(8-966)

[0162] log2LfhstSize=(nTbW>=8&&nTbH>=8)? 3:2(8-967)

[0163] nLfhstSize=1<<log2LfhstSize(8-968)

[0164] nonZeroSize=((nTbW==4&&nTbH==4)||(nTbW==8&&nTbH==8))? 8:16(8-969)

[0165] - When intra_mip_flag[xTbComp][yTbComp] is equal to 1 and cIdx is equal to 0, predModeIntra is set equal to INTRA_PLANAR.

[0166] - When predModeIntra is equal to INTRA_LT_CCLM, INTRA_L_CCLM, or INTRA_T_CCLM, predModeIntra is set equal to IntraPredModeY[xTbY+nTbW / 2][yTbY+nTbH / 2].

[0167] - Invoke the wide angle intra prediction mode mapping process as specified in section 8.4.5.2.6 with: predModeIntra, nTbW, nTbH and cIdx as inputs, and modified predModeIntra as output.

[0168] - The values ​​of the list u[x], where x = 0..nonZeroSize-1, are derived as follows:

[0169] xC=DiagScanOrder[2][2][x][0](8-970)

[0170] yC=DiagScanOrder[2][2][x][1](8-971)

[0171] u[x]=d[xC][yC](8-972)

[0172] - The one-dimensional low-frequency non-separable transform process as specified in Section 8.7.4.2 is called with the input length nonZeroSize of the scaled transform coefficients, the transform output length nTrS set equal to nLfnStOutSize, the list u[x] of scaled non-zero transform coefficients where x=0..nonZeroSize-1, the intra prediction mode predModeIntra selected by the LFNST set, and the LFNST index lfnst_idx[xTbY][yTbY] selected by the transform in the selected LFNST set as input, and the list v[x] where x=0..nLfnstOutSize-1 as output.

[0173] - The matrix d[x][y], where x=0..nLfnstSize-1, y=0..nLfnstSize-1 is derived as follows:

[0174] - If predModeIntra is less than or equal to 34, the following applies:

[0175] d[x][y]=(y<4)? v[x+(y<<log2LfnstSize)]: (8-973)

[0176] ((x<4)?v[32+x+((y-4)<<2)]:d[x][y])

[0177] - Otherwise, the following applies:

[0178] d[x][y]=(x<4)? v[y+(x<<log2LfnstSize)]: (8-974)

[0179] ((y<4)?v[32+y+((x-4)<<2)]:d[x][y])

[0180] The variable implicitMtsEnabled is exported as follows:

[0181] - implicitMtsEnabled is set equal to 1 if sps_mts_enabled_flag is equal to 1 and one of the following conditions is true:

[0182] -IntraSubPartitionsSplitType is not equal to ISP_NO_SPLIT

[0183] -cu_sbt_flag is equal to 1 and Max(nTbW, nTbH) is less than or equal to 32

[0184] -sps_explicit_mts_intraenabled_flag is equal to 0 and CuPredMode[0][xTbY][yTbY] is equal to MODE_INTRA and lfnst_idx[x0][y0] is equal to 0 and intra_mip_flag[x0][y0] is equal to 0

[0185] - Otherwise, implicitMtsEnabled is set equal to 0.

[0186] The variable trTypeHor that specifies the horizontal transformation kernel and the variable trTypeVer that specifies the vertical transformation kernel are derived as follows:

[0187] -If cIdx is greater than 0, trTypeHor and trTypeVer are set equal to 0.

[0188] Otherwise, if implicitMtsEnabled is equal to 1, the following applies:

[0189] - If IntraSubPartitionsSplitType is not equal to ISP_NO_SPLIT or sps_explicit_mts_intra_enabled_flag is equal to 0 and CuPredMode[0][xTbY][yTbY] is equal to MODE_INTRA, trTypeHor and trTypeVer are derived as follows:

[0190] trTypeHor=(nTbW>=4&&nTbW<=16)? 1:0(8-975)

[0191] trTypeVer=(nTbH>=4&&nTbH<=16)? 1:0(8-976)

[0192] - Otherwise (cu_sbt_flag is equal to 1), trTypeHor and trTypeVer specified in Table 8-15 depend on cu_sbt_horizontal_flag and cu_sbt_pos_flag.

[0193] - Otherwise, trTypeHor and trTypeVer specified in Table 8-14 depend on tu_mts_idx[xTbY][yTbY].

[0194] The variables nonZeroW and nonZeroH are derived as follows:

[0195] - If lfnst_idx[xTbY][yTbY] is not equal to 0 and nTbW is greater than or equal to 4 and nTbH is greater than or equal to 4, then the following applies:

[0196] nonZeroW=(nTbW==4||nTbH==4)? 4:8(8-977)

[0197] nonZeroH=(nTbW==4||nTbH==4)? 4:8(8-978)

[0198] - Otherwise, the following applies:

[0199] nonZeroW=Min(nTbW, (trTypeHor>0)?16:32)(8-979)

[0200] nonZeroH=Min(nTbH, (trTypeVer>0)?16:32)(8-980)

[0201] The (nTbW)x(nTbH) matrix r of the residual samples is derived as follows:

[0202] 1. When nTbH is greater than 1, each (vertical) column is transformed into e[x][y] (where x=0..nonZeroW-1, y=00..nTbH-1) by scaling the transform coefficients d[x][y] (where x=0..nonZeroW-1, y=0..nonZeroH-1) using the following one-dimensional transform process specified by calling section 8.7.4.4: for each column x=0..nonZeroW-1, the height nTbH of the transform block, the non-zero height nonZeroH of the scaled transform coefficients, the list d[x][y], where y=0..nonZeroH-1 and the transform type variable trType set equal to trTypeVer are taken as input, and the output is the list e[x][y], where y=0..nTbH-1.

[0203] 2. When both nTbH and nTbW are greater than 1, the intermediate sample value g[x][y], where x = 0..nonZeroW-1, y = 0..nTbH-1, is derived as follows:

[0204] g[x][y]=Clip3(CoeffMin, CoeffMax, (e[x][y]+64)>>7)(8-981)

[0205] 3. When nTbW is greater than 1, each (horizontal) row of the resulting matrix g[x][y] (where x = 0..nonZeroW-1, y = 0...nTbH-1) is transformed into r[x][y] (where x = 0...nTbW-1, y = 0..nTbH-1) by using the following one-dimensional transformation process specified in Section 8.7.4.4: for each row y = 0...nTbH-1, the width nTbW of the transform block, the non-zero width nonZeroW of the resulting matrix g[x][y], the list g[x][y], where x = 0..nonZeroW-1 and the transform type variable trType set equal to trTypeHor are taken as input, and the output is the list r[x][y], where y = 0..nTbW-1.

[0206] 4. When nTbW is equal to 1, r[x][y] is set equal to e[x][y], where x = 0..nTbW-1, y = 0..nTbH-1.

[0207] Table 8-14 - Specification of trTypeHor and trTypeVer depending on tu_mts_idx[x][y]

[0208] tu_mts_idx[x0][y0] 0 1 2 3 4 trTypeHor 0 1 2 1 2 trTypeVer 0 1 1 2 2

[0209] Table 8-15 - Specification of trTypeHor and trTypeVer depending on cu_sbt_horizontal_flag and cu_sbt_pos_flag

[0210] cu_sbt_horizontal_flag cu_sbt_pos_flag trTypeHor trTypeVer 0 0 2 1 0 1 1 1 1 0 1 2 1 1 1 1

[0211] 8.7.4.2 Low-frequency inseparable transformation process

[0212] The inputs to this process are:

[0213] - variable nonZeroSize, specifies the transform input length,

[0214] - variable nTrS, specifies the transform output length,

[0215] - scale the list x[j] of non-zero transform coefficients, where j = 0..nonZeroSize-1,

[0216] - variable predModeIntra, specifies the intra prediction mode selected by the LFNST set,

[0217] - The variable lfnstIdx specifies the LFNST index selected by the transform in the selected LFNST set.

[0218] The output of this process is a list y[i] of transformed samples, where i = 0..nTrS-1.

[0219] The transform matrix derivation process as specified in Section 8.7.4.3 is called with the transform output length nTrS, the intra prediction mode predModeIntra selected by the LFNST set, and the LFNST index lfnstIdx of the transform selection in the selected LFNST set as input, and the (nTrS)x(nonZeroSize) LFNST matrix lowFreqTransMatrix as output.

[0220] The list of transformed samples y[i], where i = 0..nTrS-1, is derived as follows:

[0221]

[0222] 8.7.4.3 Low-frequency inseparable transformation matrix derivation process

[0223] The inputs to this process are:

[0224] - variable nTrS, specifies the transform output length,

[0225] - variable predModeIntra, specifies the intra prediction mode selected by the LFNST set,

[0226] - The variable lfnstIdx specifies the LFNST index selected by the transform in the selected LFNST set.

[0227] The output of this process is the transformation matrix lowFreqTransMatrix.

[0228] The variable lfnstTrSetIdx is specified in Table 8-16 and depends on predModeIntra.

[0229] Table 8-16 - Specification of lfnstTrSetIdx

[0230]

[0231]

[0232] Based on nTrS, lfnstTrSetIdx, and lfnstIdx, the transformation matrix lowFreqTransMatrix is ​​derived as follows:

[0233] - If nTrS is equal to 16, lfnstTrSetIdx is equal to 0, and lfnstIdx is equal to 1, the following applies:

[0234] lowFreqTransMatrix[m][n]=

[0235] {

[0236] {108 -44 -15 1 -44 19 7 -1 -11 6 2 -1 0 -1 -1 0}

[0237] {-40 -97 56 12 -11 29 -12 -3 18 18 -15 -3 -1 -3 2 1}

[0238] {25 -31 -1 7 100 -16 -29 1 -54 21 14 -4 -7 2 ​​4 0}

[0239] {-32 -39 -92 51 -6 -16 36 -8 3 22 18 -15 4 1 -5 2}

[0240] {8 -9 33 -8 -16 -102 36 23 -4 38 -27 -5 5 16 -8 -6}

[0241] {-25 5 16 -3 -38 14 11 -3 -97 7 26 1 55 -10 -19 3}

[0242] {8 9 16 1 37 36 94 -38 -7 3 -47 11 -6 -13 -17 10}

[0243] {2 34 -5 1 -7 24 -25 -3 8 99 -28 -29 6 -43 21 11}

[0244] {-16 -27 -39 -109 6 10 16 24 3 19 10 24 -4 -7 -2 -3}

[0245] {-9 -10 -34 4 -9 -5 -29 5 -33 -26 -96 33 14 4 39 -14}

[0246] {-13 1 4 -9 -30 -17 -3 -64 -35 11 17 19 -86 6 36 14}

[0247] {8 -7 -5 -15 7 -30 -28 -87 31 4 4 33 61 -5 -17 22}

[0248] {-2 13 -6 -4 -2 28 -13 -14 -3 37 -15 -3 -2 107 -36 -24}

[0249] {4 9 11 31 4 9 16 19 12 33 32 94 12 0 34 -45}

[0250] {2 -2 8 -16 8 5 28 -17 6 -7 18 -45 40 36 97 -8}

[0251] {0 -2 0 -10 -1 -7 -3 -35 -1 -7 -2 -32 -6 -33 -16 -112}

[0252] },

[0253] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 0, and lfnstIdx is equal to 2, then the following

[0254] Applicable:

[0255] lowFreqTransMatrix[m][n]=

[0256] {

[0257] {119 -30 -22 -3 -23 -2 3 2 -16 3 6 0 -3 2 1 0}

[0258] {-27 -101 31 17 -47 2 22 3 19 30 -7 -9 5 3 -5 -1}

[0259] {0 58 22 -15 -102 2 38 2 10 -13 -5 4 14 -1 -9 0}

[0260] {23 4 66 -11 22 89 -2 -26 13 -8 -38 -1 -9 -20 -2 8}

[0261] {-19 -5 -89 2 -26 76 -11 -17 20 13 18 -4 1 -15 3 5}

[0262] {-10 -1 -1 6 23 25 87 -7 -74 4 39 -5 0 -1 -20 -1}

[0263] {-17 -28 12 -8 -32 14 -53 -6 -68 -67 17 29 2 6 25 4}

[0264] {1 -24 -23 1 17 -7 52 9 50 -92 -15 27 -15 -10 -6 3}

[0265] {-6-17 -2 -111 7 -17 8 -42 9 18 16 25 -4 2 -111}

[0266] {9 5 35 0 6 21 -9 34 44 -3 102 11 -7 13 11 -20}

[0267] {4 -5 -5 -10 15 19 -2 6 6 -12 -13 6 95 69 -29 -24}

[0268] {-6 -4 -9 -39 1 22 0 102 -19 19 -32 30 -16 -14 -8 -23}

[0269] {4 -4 7 8 4 -13 -18 5 0 0 21 22 58 -88 -54 28}

[0270] {-4 -7 0 -24 -7 0 -25 3 -3 -30 8 -76 -34 4 -80 -26}

[0271] {0 6 0 30 -6 1 -13 -23 1 20 -2 80 -44 37 -68 1}

[0272] {0 0 -1 5 -1 -7 1 -34 -2 3 -6 19 5 -38 11-115}

[0273] },

[0274] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 1, and lfnstIdx is equal to 1, then the following

[0275] Applicable:

[0276] lowFreqTransMatrix[m][n]=

[0277] {

[0278] {-111 39 4 3 44 11 -12 -1 7 -16 -5 2 3 -1 4 2}

[0279] {-47 -27 15 -1 -92 43 20 -2 20 39 -16 -5 10 -5 -13 2}

[0280] {-35 -23 4 4 -17 -72 32 6 -59 18 50 -6 0 40 0 ​​-13}

[0281] {13 93 -27 -4 -48 13 -34 4 -52 11 1 10 3 16 -3 1}

[0282] {-11 -27 1 2 -47 -4 -36 10 -2 -85 14 29 -20 -2 57 4}

[0283] {0 -35 32 -2 26 60 -3 -17 -82 1 -30 0 -37 21 3 12}

[0284] {-17 -46 -92 14 7 -10 -39 29 -17 27 -28 17 1 -15 -13 17}

[0285] {4 -10 -23 4 16 58 -17 26 30 21 67 2 -13 59 13 -40}

[0286] {5 -20 32 -5 8 -3 -46 -7 -4 2 -15 24 100 44 0 5}

[0287] {-4 -1 38 -18 -7 -42 -63 -6 33 34 -23 15 -65 33 -20 2}

[0288] {-2 -10 35 -19 5 8 -44 14 -25 25 58 17 7 -84 -16 -18}

[0289] {5 13 18 34 11 -4 18 18 5 58 -3 42 -2 -10 85 38}

[0290] {-5 -7 -34 -83 2 -1 -4 -73 4 20 15 -12 4 -3 44 12}

[0291] {0 4 -2 -60 5 9 42 34 5 -14 9 80 -5 13 -38 37}

[0292] {-1 2 7 -57 3 -7 9 68 -9 6 -49 -20 6 -4 36 -64}

[0293] {-1 0 -12 23 1 -4 17 -53 -3 4 -21 72 -4 -8 -3 -83}

[0294] },

[0295] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 1, and lfnstIdx is equal to 2, then the following

[0296] Applicable:

[0297] lowFreqTransMatrix[m][n]=

[0298] {

[0299] {88 -55 6 -3 -66 27 9 -2 11 11 -13 1 -2 -7 1 2}

[0300] {-58 -20 27 -2 -27 75 -29 0 47 -42 -11 11 -9 -3 19 -4}

[0301] {-51 23 -22 5 -63 3 37 -5 1 64 -35 -4 29 -31 -11 13}

[0302] {-27 -76 49 -2 40 14 9 -17 -56 36 -25 6 14 3 -6 8}

[0303] {19 -4-36 22 52 7 36 -23 28 -17 -64 15 -5-44 48 9}

[0304] {29 50 13-10 1 34 -59 1 -51 4 -16 30 52 -33 24 -5}

[0305] {-12 -21 -74 43 -13 39 18 -5 -58 -35 27 -5 19 26 6 -5}

[0306] {19 38 -10 -5 28 66 0 -5 -4 19 -30 -26 -40 28 -60 37}

[0307] {-6 27 18 -5 -37 -18 12 -25 -44 -10 -38 37 -66 45 40 -7}

[0308] {-13 -28 -45 -39 0 -5 -39 69 -23 16 -12 -18 -50 -31 24 13}

[0309] {-1 8 24 -51 -15 -9 44 10 -28 -70 -12 -39 24 -18 -4 51}

[0310] {-8 -22 -17 33 -18 -45 -57 -27 0 -31 -30 29 -2-13 -53 49}

[0311] {1 12 32 51 -8 8 -2 -31 -22 4 46 -39 -49 -67 14 17}

[0312] {4 5 24 60 -5 -14 -23 38 9 8 -34 -59 24 47 42 28}

[0313] {-1 -5 -20 -34 4 4 -15 -46 18 31 42 10 10 27 49 78}

[0314] {-3 -7 -22 -34 -5 -11 -36 -69 -1 -3 -25 -73 5 4 4 -49}

[0315] },

[0316] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 2, and lfnstIdx is equal to 1, then the following

[0317] Applicable:

[0318] lowFreqTransMatrix[m][n]=

[0319] {

[0320] {-112 47 -2 2 -34 13 2 0 15 -7 1 0 8 -3 -1 0}

[0321] {29 -7 1 -1-108 40 2 0 -45 13 4 -1 8 -5 1 0}

[0322] {-36 -87 69 -10 -17 -33 26 -2 7 14 -11 2 6 8 -7 0}

[0323] {28 -5 2 -2 -29 13 -2 0 103 -36 -4 1 48 -16 -4 1}

[0324] {-12 -24 15 -3 26 80 -61 9 15 54-36 2 0 -4 6 -2}

[0325] {18 53 69 -74 14 24 28 -30 -6 -7 -11 12 -5 -7 -6 8}

[0326] {5 -1 2 0 -26 6 0 1 45 -9 -1 0-113 28 8 -1}

[0327] {-13 -32 18 -2 15 34 -27 7 -25 -8047 -1 -16 -50 28 2}

[0328] {-4 -13 -10 19 18 46 60 -48 16 3360 -48 1 0 5 -2}

[0329] {15 33 63 89 8 15 25 40 -4 -8 -15 -8 -2 -6 -9 -7}

[0330] {-8 -24 -27 15 12 41 26 -29 -17 -50 -39 27 0 35 -67 26}

[0331] {-2 -6 -24 13 -1 -8 37 -22 3 18 -51 22 -23 -95 17 17}

[0332] {-3 -7 -16 -21 10 24 46 75 8 20 38 72 1 2 1 7}

[0333] {2 6 10 -3 -5 -16 -31 12 7 24 41 -16 -16 -41 -89 49}

[0334] {4 8 21 40 -4 -11 -28 -57 5 14 31 70 7 18 32 52}

[0335] {0 1 4 11 -2 -4 -13 -34 3 7 20 47 -6 -19 -42 -101}

[0336] },

[0337] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 2, and lfnstIdx is equal to 2, then the following applies:

[0338] lowFreqTransMatrix[m][n]=

[0339] {

[0340] {-99 39 -1 2 65 -20 -5 0 -15 -2 5 -1 0 3 -1 0}

[0341] {58 42 -33 3 33 -63 23 -1 -55 32 3 -5 21 -2 -8 3}

[0342] {-15 71 -44 5 -58 -29 25 3 62 -7 -4 -4 -19 4 0 1}

[0343] {46 5 4 -6 71 -12 -15 5 52 -38 13 -2 -63 23 3 -3}

[0344] {-14 -54 -29 29 25 -9 61 -29 27 44-48 5 -27 -21 12 7}

[0345] {-3 3 69 -42 -11 -50 -26 26 24 63 -19 -5 -18 -22 12 0}

[0346] {17 16-2 1 38 18 -12 0 62 1 -14 5 89 -42 8 -2}

[0347] {15 54 -8 6 6 60 -26 -8 -30 17 -38 22 -43 -45 42 -7}

[0348] {-6 -17 -55 -28 9 30-8 58 4 34 41 -52 -16 -36 -20 16}

[0349] {-2-1 -9 -79 7 11 48 44 -13 -34 -55 6 12 23 20 -11}

[0350] {7 29 14 -6 12 53 10 -11 14 59 -15 -3 5 71 -54 13}

[0351] {-5 -24 -53 15 -3 -15 -61 26 6 30 -16 23 13 56 44 -35}

[0352] {4 8 21 52 -1 -1 -5 29 -7 -17 -44 -84 8 20 31 39}

[0353] {-2 -11 -25 -4 -4 -21 -53 2 -5 -26 -64 19 -8 -19 -73 39}

[0354] {-3 -5 -23 -57 -2 -4 -24 -75 1 3 9 -25 6 ​​15 41 61}

[0355] {1 1 7 18 1 2 16 47 2 5 24 67 3 9 25 88}

[0356] },

[0357] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 3, and lfnstIdx is equal to 1, the following applies:

[0358] lowFreqTransMatrix[m][n]=

[0359] {

[0360] {-114 37 3 2 -22 -23 14 0 21 -17 -5 2 5 2 -4 -1}

[0361] {-19 -41 19 -2 85 -60 -11 7 17 31 -34 2 -11 19 2 -8}

[0362] {36 -25 18 -2 -42 -53 35 5 46 -60 -25 19 8 21 -33 -1}

[0363] {-27 -80 44 -3 -58 1 -29 19 -41 18 -12 -7 12 -17 7 -6}

[0364] {-11 -21 37 -10 44 -4 47 -12 -37 -41 58 18 10 -46 -16 31}

[0365] {15 47 10 -6 -16 -44 42 10 -80 25 -40 21 -23 -2 3 -14}

[0366] {13 25 79 -39 -13 10 31 -4 49 45 12 -8 3 -1 43 7}

[0367] {16 11 -26 13 -13 -74 -20 -1 5 -6 29 -47 26 -49 54 2}

[0368] {-8 -34 -26 7 -26 -19 29 -37 1 22 46 -9 -81 37 14 20}

[0369] {-6 -30 -42 -12 -3 5 57 -52 -2 37 -12 6 74 10 6 -15}

[0370] {5 9 -6 42 -15 -18 -9 26 15 58 14 43 23 -10-3775}

[0371] {-5 -23 -23 36 3 22 36 40 27 -4 -16 56 -25 -46 56 -24}

[0372] {1 3 23 73 8 5 34 46 -12 2 35 -38 26 52 2 -31}

[0373] {-3 -2 -21 -52 1 -10-17 44 -19 -20 30 45 27 61 49 21}

[0374] {-2 -7 -33 -56 -4 -6 21 63 15 31 32 -22 -10 -26 -52 -38}

[0375] {-5 -12 -18 -12 8 22 38 36 -5 -15 -51 -63 -5 0 15 73}

[0376] },

[0377] - Otherwise, if nTrS is equal to 16, lfnstTrSetIdx is equal to 3, and lfnstIdx is equal to 2, then the following

[0378] Applicable:

[0379] lowFreqTransMatrix[m][n]=

[0380] {

[0381] {-102 22 7 2 66 -25 -6 -1 -15 14 1 -1 2 -2 1 0}

[0382] {12 93 -27 -6 -27 -64 36 6 13 5 -23 0 -2 6 5 -3}

[0383] {-59 -24 17 1 -62 -2 -3 2 83 -12 -17 -2 -24 14 7 -2}

[0384] {-33 23 -36 11 -21 50 35 -16 -23 -78 16 19 22 15 -30 -5}

[0385] {0 -38 -81 30 27 5 51 -32 24 36 -16 12 -24 -8 9 1}

[0386] {28 38 8 -9 62 32 -13 2 51 -32 15 5 -66 28 0 -1}

[0387] {11 -35 21 -17 30 -18 31 18 -11 -36 -80 12 16 49 13 -32}

[0388] {-13 23 22 -36 -12 64 39 25 -19 23 -36 9 -30 -58 33 -7}

[0389] {-9 -20 -55 -83 3 -2 1 62 8 2 27 -28 7 15 -11 5}

[0390] {-6 24 -38 23 -8 40 -49 0 -7 9 -25 -44 23 39 70 -3}

[0391] {12 17 17 0 32 27 21 2 67 11 -6 -10 89 -22 -12 16}

[0392] {2 -9 8 45 7 -8 27 35 -9 -31 -17 -87 -23 -22 -19 44}

[0393] {-1 -9 28 -24 -1 -10 49 -30 -8 -740 1 4 33 65 67}

[0394] {5 -12 -24 -17 13 -34 -32 -16 14 -67 -7 9 7 -74 49 1}

[0395] {2 -6 11 45 3 -10 33 55 8 -5 59 4 7 -4 44 -66}

[0396] {-1 1 -14 36 -1 2 -20 69 0 0 -15 72 3 4 5 65}

[0397] },

[0398] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 0, and lfnstIdx is equal to 1, then the following applies:

[0399] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0400] lowFreqTransMatrixCol0to15=

[0401] {

[0402] {-117 28 18 2 4 1 2 1 32 -18 -2 0 -1 0 0 0}

[0403] {-29 -91 47 1 9 0 3 0 -54 26 -8 3 0 1 0 0}

[0404] {-10 62 -11 -8 -2 -2 -1 -1 -95 3 32 0 4 0 2 0}

[0405] {-15 15 -10 -2 1 0 1 0 10 112 -20 -17 -4 -4 -1 -2}

[0406] {32 39 92 -44 4 -10 1 -4 26 12 -15 13 -5 2 -2 0}

[0407] {-10 1 50 -15 2 -3 1 -1 -28 -15 14 6 1 1 1 0}

[0408] {1 -33 -11 -14 7 -2 2 0 29 -12 37 -7 -4 0 -1 0}

[0409] {0 6 -6 21 -4 2 0 0 -20 -24 -104 30 5 5 1 2}

[0410] {-13 -13 -37 -101 29 -11 8 -3 -12 -15 -20 2 -11 5 -2 1}

[0411] {6 1 -14 -36 9 -3 2 0 10 9 -18 -1 -3 1 0 0}

[0412] {-12 -2 -26 -12 -9 2 -1 1 -3 30 4 34 -4 0 -1 0}

[0413] {0 -3 0 -4 -15 6 -3 1 -7 -15 -28 -86 19 -5 4 -1}

[0414] {-1 9 13 5 14 -2 2 -1 -8 3 -4 -62 4 1 1 0}

[0415] {6 2 -3 2 10 -1 2 0 8 3 -1 -20 0 1 0 0}

[0416] {6 9 -2 35 110 -22 11 -4 -2 0 -3 1 -18 12 -3 2}

[0417] {-1 7 -2 9 -11 5 -1 1 -7 2 ​​-22 4 -13 0 -1 0}

[0418] },

[0419] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol16to31[m-16][n], where m=16..31, n=0..15

[0420] lowFreqTransMatrixCol16to31=

[0421] {

[0422] {14 -1 -3 0 -1 0 0 0 2 0 0 0 0 0 0 0}

[0423] {33 5 -9 -1 -2 0 -1 0 -3 3 0 0 0 0 0 0}

[0424] {32 -30 -4 4 -1 1 0 0 6 2 -5 0 0 0 0 0}

[0425] {-20 -26 31 1 0 0 0 0 2 -16 -1 6 0 1 0 0}

[0426] {29 -16 -22 8 0 1 0 1 -20 6 4 -3 1 0 0 0}

[0427] {-99 -4 9 5 5 2 2 1 44 -10 -11 1 -2 0 -1 0}

[0428] {6 -99 3 26 -1 5 0 2 14 30 -27 -2 1 -1 0 -1}

[0429] {-7 -46 10 -14 7 0 1 0 9 21 7 -6 -2 -1 0 -1}

[0430] {-12 10 26 12 -6 0 -1 0 -32 -2 11 3 3 -1 1 0}

[0431] {38 26 -13 -1 -5 -1 -1 0 102 3 -14 -1 -5 -1 -2 0}

[0432] {-30 3 -92 14 19 0 3 0 -11 34 21 -33 1 -2 0 -1}

[0433] {-5 -17 -41 42 -6 2 -1 1 -1 -40 37 13 -4 2 -1 1}

[0434] {-12 23 16 -11 -17 0 -1 0 -11 97 -3 -3 0 -6 0 -2}

[0435] {-4 4 -16 0 -2 0 1 0 34 23 6 -7 -4 -2 -1 0}

[0436] {-5 -4 -22 8 -25 3 0 0 -3 -21 2 -3 9 -2 1 0}

[0437] {0 28 0 76 4 -6 0 -2 -13 5 -76 -4 33 -1 3 0}

[0438] }

[0439] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0440] lowFreqTransMatrixCol32to47=

[0441] {

[0442] {3 0 -1 0 1 0 0 0 1 0 0 0 1 0 0 0}

[0443] {7 2 -2 0-1 1 0 0 2 1 -1 0 0 0 0 0}

[0444] {6 -3 0 0 2 0 -1 0 2 -1 0 0 1 0 0 0}

[0445] {1 -4 0 0 0 -3 0 1 0 -1 0 0 0 -2 0 0}

[0446] {1 -4 -3 2 -4 1 0 0 1 -1 -2 1 -2 0 0 0}

[0447] {-5 4 -3 0 8 -1 -2 0 -2 1 -1 0 4 0 -1 0}

[0448] {-6 6 6 -3 1 3 -3 0 -1 1 1 0 0 1 -1 0}

[0449] {2 2 5 -2 0 3 4-1 0 0 1 0 0 1 2 -1}

[0450] {11 -5 -1 6 -4 2 1 0 3 -1 1 2 -1 0 0 0}

[0451] {-29 10 10 0 10 -4 -1 1 -7 1 2 1 2 -1 0 0}

[0452] {-9 -4 18 3 2 0 0 -2 -1 -1 3 0 0 0 0 -1}

[0453] {-10 13 -1 -4 4 -4 3 4 -2 2 -1 -1 1 -1 1 2}

[0454] {-21 -5 23 0 2 -2 -1 6 -3 -3 1 0 0 0 0 2}

[0455] {108 -5 -30 6 -27 10 7 -2 11 -3 -1 1 -4 1 0 1}

[0456] {-7 1 3 -5 3 0 -1 0 0 1 0 -1 1 0 0 0}

[0457] {9 18 -3 -35 -4 -1 6 1 1 2 0 -3 -1 0 2 0}

[0458] },

[0459] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 0, and lfnstIdx is equal to 2, then the following applies:

[0460] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0461] lowFreqTransMatrixCol0to15=

[0462] {

[0463] {-108 48 9 1 1 1 0 0 44 -6 -9 -1 -1 0 -1 0}

[0464] {55 66 -37 -5 -6 -1 -2 0 67 -30 -20 4 -2 0 -1 0}

[0465] {2 86 -21 -13 -4 -2 -1 -1 -88 5 6 4 5 1 1 0}

[0466] {-24 -21 -38 19 0 4 -1 2 -23 -89 31 20 2 3 1 1}

[0467] {9 20 98 -26 -3 -5 0 -2 -9 -26 15 -16 2 0 1 0}

[0468] {-21 -7 -37 10 2 2 -1 1 -10 69 -5 -7 -2 -2 0 -1}

[0469] {-10 -25 4 -17 8 -2 2 -1 -27 -17 -71 25 8 2 1 1}

[0470] {2 5 10 64 -9 4 -3 1 -4 8 62 3 -17 1 -2 0}

[0471] {-11 -15 -28 -97 6 -1 4 -1 7 3 57 -15 10 -2 0 -1}

[0472] {9 13 24 -6 7 -2 1 -1 16 39 20 47 -2 -2 -2 0}

[0473] {-7 11 12 7 2 -1 0 -1 -14 -1 -24 11 2 0 0 0}

[0474] {0 0 7 -6 23 -3 3 -1 5 1 18 96 13 -9 -1 -1}

[0475] {-2 -6 -1 -10 0 1 1 0 -7 -2 -28 20 -15 4 -3 1}

[0476] {-1 6 -16 0 24-3 1 -1 2 6 6 16 18 -7 1 -1}

[0477] {-5 -6 -3 -19 -104 18 -4 3 0 6 0 35 -41 20 -2 2}

[0478] {-1 -2 0 23 -9 0 -2 0 1 1 8 -1 29 1 1 0}

[0479] },

[0480] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol1 6to31[m-16][n], where m=16..31, n=0..15

[0481] lowFreqTransMatrixCol16to31=

[0482] {

[0483] {9 -9 -1 1 0 0 0 0 3 -1 1 0 0 0 0 0}

[0484] {-31 -19 14 4 1 1 1 0 -6 3 5 -2 0 0 0 0}

[0485] {14 -5 0 3 0 0 0 0 10 -5 -2 0 -1 0 0 0}

[0486] {-30 26 36 -8 -2 -2 0 -1 14 18 -7 -9 -1 -1 0 0}

[0487] {-61 -3 -2 3 7 1 1 0 12 16 -6 -1 0 -1 0 0}

[0488] {-93 2 19 0 3 0 2 0 17 4 0 0 -1 0 0 0}

[0489] {-4-66 28 36 -5 3 0 1 -10 20 33 -13 -8 0 0 -1}

[0490] {-3 -75 5 -14 1 4 0 1 -36 3 18 -4 4 0 1 0}

[0491] {-1 -27 13 6 1 -1 0 0 -34 -6 0 3 4 1 2 0}

[0492] {28 23 76 -5 -25 -3 -3 -1 6 36 -7 -39 -4 -1 0 -1}

[0493] {-20 48 11 -13 -5 -2 0 -1 -105 -19 17 0 6 2 3 0}

[0494] {-21 -7 -42 14 -24 -3 0 0 11 -47 -7 3 -5 9 1 2}

[0495] {-2 -32 -2 -66 3 7 1 2 -11 13 -70 5 43 -2 3 0}

[0496] {-3 11 -63 9 4 -5 2 -1 -22 94 -4-6-4-4 1-2}

[0497] {-2 10 -18 16 21 3 -2 0 -2 11 6 -10 6 -3 -1 0}

[0498] {3 -6 13 76 30 -11 -1 -2 -26 -8 -69 7 -9 -7 3 -1}

[0499] }，

[0500] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47 and n = 0..15

[0501] lowFreqTransMatrixCol32to47 =

[0502] {

[0503] {1 -1 0 0 1 0 0 0 0 -1 0 0 0 0 0 0}

[0504] {-7 -1 1 0 -1 1 1 0 -2 -1 1 0 0 0 0 0}

[0505] {6 -5 0 1 2 -1 0 0 1 -1 0 0 1 0 0 0}

[0506] {1 3 -2 -1 3 2 -2 -1 0 1 0 0 1 1 -1 0}

[0507] {2 0 -8 1 3 1 -1 1 0 -1 -2 0 1 0 -1 0}

[0508] {5 -4 -2 0 4 -2 0 1 0 0 0 0 2 -1 0 0}

[0509] {3 6 -3 -7 -1 3 3 -1 1 0 -1 0 0 1 1 -1}

[0510] {1 14 -2 -8 -2 1 -3 0 2 2 -1 -2 0 1 -1 0}

[0511] {-2 8 1 5 -2 0 -3 1 1 1 0 2 -1 0 -1 0}

[0512] {2 -4 -18 -3 -1 -1 -2 -2 1 -2 -2 0 0 0 -1 -1}

[0513] {-14 8 8 2 1 2 -1 -2 3 0 -1 0 0 0 0 0}

[0514] {0 -1 19 -1 1 0 -1 -6 -1 1 2 0 1 0 0 -2}

[0515] {8 -14 -3 43 -1 2 7 -1 1 -2 1 3 -1 1 1 0}

[0516] {10 23 -19 -5 0 -6 -4 6 3 -2 1 1 0 -1 0 0}

[0517] {-1 5 -1 -6 -1 -1 -1 -1 -1 0 0 0 0 0 0 -1}

[0518] {-10 -34 -25 13 -1 0 11 5 1 -1 1 -2 0 0 2 0}

[0519] },

[0520] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 1, and lfnstIdx is equal to 1, then the following applies:

[0521] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0522] lowFreqTransMatrixCol0to15=

[0523] {

[0524] {110 -49 -3 -4 -1 -1 0 -1 -38 -1 10 0 2 0 1 0}

[0525] {-43 -19 17 -1 3 0 1 0 -98 46 14 -1 2 0 1 0}

[0526] {-19 17 -7 3 -2 1 -1 0 -32 -59 29 3 4 0 2 0}

[0527] {-35 -103 39 1 7 0 2 0 38 -13 25 -6 1 -1 0 0}

[0528] {9 5 -6 -1 -1 0 -1 0 42 4 21 -11 1 -3 1 -1}

[0529] {-5 -5 -28 9 -3 2 -1 1 -20 -78 22 16 1 3 0 1}

[0530] {14 17 27 -12 1 -3 1 -1 8 19 -13 4 -2 1 -1 0}

[0531] {7 35 17 -4 -1 0 0 0 3 8 54 -17 1 -2 1 -1}

[0532] {-13 -27 -101 24 -8 6 -32 11 43 6 28 -6 3 -1 1}

[0533] {-11 -13 -3 -10 3 -1 1 0 -19 -19 -37 8 4 2 0 1}

[0534] {-4 -10 -24 -11 3 -2 0 -1 -6 -37 -45 -17 8 -2 2 -1}

[0535] {-2 1 13 -17 3 -5 1 -2 3 0 -55 22 6 1 1 0}

[0536] {3 1 5 -15 1 -2 1 -1 7 4 -7 29 -1 2 -1 1}

[0537] {-4 -8 -1 -50 6 -4 2 -2 -1 5 -22 20 6 1 0 0}

[0538] {5 -1 26 102 -13 12 -4 4 -4 -2 -40 -7 -23 3 -5 1}

[0539] {-5 -6 -27 -22 -12 0 -3 0 -5 8 -20 -83 0 0 0 0}

[0540] },

[0541] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol1 6to31[m-16][n], where m=16..31, n=0..15

[0542] lowFreqTransMatrixCol16to31=

[0543] {

[0544] {-9 13 1 -2 0 0 0 0 -4 2 -3 0 0 0 0 0}

[0545] {26 26 -15 -3 -2 -1 -1 0 11 -7 -9 2 0 0 0 0}

[0546] {-72 43 34 -9 3 -2 1 -1 13 36 -18 -10 0 -2 0 -1}

[0547] {-1 7 6 -7 1 -1 0 0 -13 14 2 -4 2 -1 0 0}

[0548] {21 70 -32 -21 0 -4 -1 -1 34 -26 -57 11 4 2 0 1}

[0549] {80 -6 25 -5 -4 -1 -1 0 6 -24 7 -9 0 0 0 0}

[0550] {48 -1 48 -15 -4 -2 -1 -1 1 60 -28 -42 5 -6 1 -2}

[0551] {10 14 -11 -34 4 -4 1 -1 -80 -7 -6 2 15 0 3 0}

[0552] {-3 14 21 -12 -7 -2 -1 -1 -23 10 -4 -12 3 0 1 0}

[0553] {-12 -30 3 -9 5 0 1 0-56 -9 -47 8 21 1 4 1}

[0554] {17 14 -58 14 15 0 2 0 -10 34 -7 28 4 -1 1 0}

[0555] {8 74 21 40 -14 0 -2 0 -36 -8 11 -13 -23 1 -3 0}

[0556] {8 3 12 -14 -9 -1 -1 0 4 29 -15 31 10 4 1 1}

[0557] {-16 -15 18 -29 -11 2 -2 1 40 -45 -19 -22 31 2 4 1}

[0558] {-1 5 8 -23 7 2 1 1 10 -11 -13 -3 12 -3 2 0}

[0559] {9 7 24 -20 41 3 6 1 15 20 12 11 17 -9 1 -2}

[0560] },

[0561] lowFreqTransMatrix[m][n] =

[0562] lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0563] lowFreqTransMatrixCol32to47 =

[0564] {

[0565] {-2 2 0 1 -1 1 0 0 -1 1 0 0 -1 0 0 0}

[0566] {9 -3 -1 2 3 -3 0 0 4 -1 0 0 2 -1 0 0}

[0567] {3 0 -12 3 6 1 -3 2 1 -1 -2 0 3 1 -1 1}

[0568] {-2 11 -6 -2 -2 4 -3 0 0 3 -2 0 -1 1 -1 0}

[0569] {-4 -32 5 24 1 -6 12 4 -3 -2 4 -2 0 -1 0 0}

[0570] {-7 3 13 -4 -3 5 1 -5 -2 3 1 -2 -1 2 -1 -2}

[0571] {11 -11 -51 11 -2 -10 -2 13 2 -6 -4 4 -2 -3 2 2}

[0572] {-16 46 1 3 2 7 -24 0 2 -2 -5 8 1 -1 -2 2}

[0573] {2 9 -10 0 1 -5 -4 4 2 -2 2 2 0 -2 1 0}

[0574] {-11 -30 10 59 -2 8 41 8 2 5 6 -7 -1 3 5 -2}

[0575] {23 34 -31 4 10 -22 -30 22 4 -15 9 20 2 -5 9 4}

[0576] {-36 6 16 -14 2 19 -4 -12 -1 0 -7 -3 0 2 -2 -1}

[0577] {61 22 55 14 13 3 -9 -65 1 -11 -21 -7 0 0 -1 3}

[0578] {-25 41 0 12 9 7 -42 12 -3 -14 2 28 5 1 6 2}

[0579] {-9 23 4 9 14 9 -14 -4 0 -12 -7 6 3 0 6 3}

[0580] {-26 -1 18 -1 -12 32 3 -18 -5 10 -25 -5 -2 1 -8 10}

[0581] },

[0582] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 1, and lfnstIdx is equal to 2, the following applies:

[0583] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0584] lowFreqTransMatrixCol0to15=

[0585] {

[0586] {80 -49 6 -4 1 -1 1 -1 -72 36 4 0 1 0 0 0}

[0587] {-72 -6 17 0 3 0 1 0 -23 58 -21 2 -3 1 -1 0}

[0588] {-50 19 -15 4 -1 1 -1 1 -58 -2 30 -3 4 -1 2 0}

[0589] {-33 -43 28 -7 4 -2 2 -1 -38 11 -8 4 1 1 0 0}

[0590] {10 66 -21 -3 -3 0 -1 0 -53 -41-2 16 -1 4 -1 1}

[0591] {18 14 13 -9 2 -2 1 -1 34 32 -31 12 -5 2 -2 1}

[0592] {21 66 -1 9 -4 2 -1 1 -21 41 -30 -10 0 -2 0 -1}

[0593] {1 -6 -24 17 -5 3 -2 1 24 10 39 -21 5 -4 2 -1}

[0594] {9 33 -24 1 4 0 1 0 6 50 26 1 -10 0 -2 0}

[0595] {-7 -9 -32 14 -3 3 -1 1 -23 -28 0 -5 -1 0 0 0}

[0596] {6 30 69 -18 5 -4 3 -1 -3 -11 -34 -16 9 -4 2 -1}

[0597] {1 -8 24 -3 7 -2 2 -1 -6 -51 -6 -4 -5 0 -1 0}

[0598] {4 10 4 17 -9 4 -2 1 5 14 32 -15 9 -3 2 -1}

[0599] {-3 -9 -23 10 -10 3 -3 1 -5 -14 -16 -27 13 -5 2 -1}

[0600] {2 11 22 2 9 -2 2 0 -6 -7 20 -32 -3 -4 0 -1}

[0601] {2 -3 8 14 -5 3 -1 1 -2 -11 5 -18 8 -3 2 -1}

[0602] },

[0603] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol1 6to31[m-16][n], where m=16..31, n=0..15

[0604] lowFreqTransMatrixCol1 6to31=

[0605] {

[0606] {26 0 -12 2 -2 1 -1 0 -7 -9 6 1 0 0 0 0}

[0607] {55 -46 -1 6 -2 1 -1 0 -22 7 17 -7 2 -1 1 0}

[0608] {6 57 -34 0 -2 0 -1 0 34 -48 -2 14 -4 3 -1 1}

[0609] {-55 24 26 -5 2 -1 1 0 15 46 -40 -1 -1 0 -1 0}

[0610] {36 -5 41 -20 3 -3 1 -1 -30 26 -32 -3 7 -2 2 -1}

[0611] {40 4 -4 -9 -3 -2 -1 -1 27 -31 -43 19 -2 3 -1 1}

[0612] {-35 -17 -3 26 -6 5 -2 2 56 3 18 -25 -1 -2 -1 -1}

[0613] {33 32 -30 4 -3 -1 -1 0 -4 13 -16 -10 0 -1 0 0}

[0614] {-27 1 -28 -21 16 -5 3 -2 -23 36 -2 40 -17 4 -3 1}

[0615] {-36 -59 -24 14 4 2 1 1 -23 -26 23 26 -3 5 0 2}

[0616] {-16 35 -35 30 -9 3 -2 1 -57 -13 6 4 -5 5 -1 1}

[0617] {38 -1 0 25 6 2 1 1 47 20 35 1 -27 1 -5 0}

[0618] {7 13 19 15 -8 1 -1 0 3 25 30 -18 1 -2 0 -1}

[0619] {-1 -13 -30 11 -5 2 -1 0 -5 -8 -22 -16 10 0 1 0}

[0620] {13 -5 -28 6 18 -4 3 -1 -26 27 -14 6 -20 0 -2 0}

[0621] {12 -23 -19 22 2 0 1 0 23 41 -7 35 -10 4 -1 1}

[0622] },

[0623] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0624] lowFreqTransMatrixCol32to47 =

[0625] {

[0626] {3 5 -1 -2 -2 -2 -1 1 1 1 0 0 -1 -1 0 0}

[0627] {9 5 -12 1 -3 -4 4 2 4 1 -2 -1 -1 -1 1 0}

[0628] {-10 7 21 -10 6 1 -11 0 -1 -1 4 2 3 0 -2 -1}

[0629] {17 -38 1 17 -3 11 15 -11 3 -1 -10 1 0 1 3 2}

[0630] {15 -8 1 17 -1 -2 4 -8 2 0 -1 3 0 0 0 -1}

[0631] {7 -49 52 10 -11 22 7 -26 -1 -6 -9 6 -2 2 4 -2}

[0632] {-15 -13 -27 9 9 -6 20 5 -3 2 -6 -9 3 -3 1 5}

[0633] {24 -26 -37 33 5 -32 55 -5 -7 22 -14 -22 1 -9 -3 13}

[0634] { 43 -13 4 -41 -19 -2 -24 17 11 -4 8 4 -3 -3 -3 -3}

[0635] {10 -26 38 7 -12 11 42 -22 -5 20 -14 -15 -1 -2 1 6}

[0636] {28 10 4 7 0 -15 7 -10 -1 7 -2 2 1 -3 0 0}

[0637] {37 -37 -9 -47 -28 5 0 18 8 6 0 -8 -4 -3 -3 1}

[0638] {11 24 22 -11 -3 37 -13 -58 -5 12 -63 26 9 -15 11 8}

[0639] {0 -29 -27 6 -27 -10 -30 9 -3 -10 -7 77 9 -13 45 -8}

[0640] {-76 -26 -4 -7 12 51 5 24 7 -17 -16 -12 -5 4 2 13}

[0641] {5 7 23 5 69 -38 -8 -32 -15 -31 24 11 2 18 11 -15}

[0642] },

[0643] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 2, and lfnstIdx is equal to 1, the following applies:

[0644] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0645] lowFreqTransMatrixCol0to15=

[0646] {

[0647] {-121 33 4 4 1 2 0 1 -1 -1 1 0 0 0 0 0}

[0648] {0 -2 0 0 0 0 0 0 121 -23 -7 -3 -2 -1 -1 0}

[0649] {-20 19 -5 2 -1 1 0 0 16 3 -2 0 0 0 0 0}

[0650] {32 108 -43 10 -9 3 -3 1 4 19 -7 1 -1 0 0 0}

[0651] {-3 0 -1 0 0 0 0 0 -29 11 -2 1 0 0 0 0}

[0652] {-4 -12 -3 1 -1 0 0 0 19 105 -31 7 -6 1 -2 0}

[0653] {7 1 2 0 0 0 0 0 4 3 -2 0 0 0 0 0}

[0654] {-8 -31 14 -4 3 -1 1 0 9 43 0 1 -1 0 0 0}

[0655] {-15 -43 -100 23 -12 6 -4 2 -6 -17 -48 10 -5 2 -1 1}

[0656] {-3 1 2 0 0 0 0 0 -6 3 1 0 0 0 0 0}

[0657] {-1 -6 -3 2 -1 0 0 0 -6 -35 9 0 2 0 0 0}

[0658] {-5 -14 -48 2 -5 1 -2 0 10 24 99 -17 10 -4 3 -1}

[0659] {-2 0 2 0 0 0 0 0 -2 0 1 0 0 0 0 0}

[0660] {-2 -10 -4 0 0 0 0 0 3 11 -1 -1 0 0 0 0}

[0661] {-2 -3 -25 -2 -3 0 -1 0 -1 -3 -1 4 -2 2 0 1}

[0662] {4 -4 28 103 -42 24 -9 7 1 2 4 0 3 -1 0 0}

[0663] },

[0664] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol16to31[m-16][n], where m=16..31, n=0..15

[0665] lowFreqTransMatrixCol16to31=

[0666] {

[0667] {24 -5 -1 -1 0 0 0 0 5 -1 0 0 0 0 0 0}

[0668] {17 1 -2 0 0 0 0 0 -27 4 2 0 0 0 0 0}

[0669] {-120 14 8 1 3 1 1 0 -18 -2 3 01 0 0 0}

[0670] {11 -30 9 -2 1 -1 0 0 0 -8 2 0 0 0 0 0}

[0671] {12 7 -1 0 0 0 0 0-117 12 9 1 3 0 1 0}

[0672] {9 46 -6 0 0 0 0 0 8 -29 9 -3 1 0 0 0}

[0673] {22 -8 1 -1 0 0 0 0 -28 -9 4 0 1 0 0 0}

[0674] {-13 -105 17 -2 2 0 0 0 -8 -25 -3 0 0 0 0 0}

[0675] {1 -5 19 -6 3 -1 1 0 2 7 15 -3 1 -1 0 0}

[0676] {0 3 -2 0 0 0 0 0 -20 8 -2 0 0 0 0 0}

[0677] {1 -6 11 -2 2 0 1 0 -9 -100 17 -1 1 0 0 0}

[0678] {4 14 32 0 2 0 1 0 -4 0 -39 6 -4 1 -1 0}

[0679] {-1 -1 1 -1 0 0 0 0 -1 -4 2 0 0 0 0 0}

[0680] {-6 -40 -15 6 -2 1 0 0 5 57 -6 2 0 0 0 0}

[0681] {-7 -8 -97 17 -9 3 -3 1 -8 -26 -61 -1 -3 -1 -1 -1}

[0682] {-1 0 -9 -42 17 -9 3 -2 -1 1 -14 6 -4 2 -1 0}

[0683] }

[0684] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0685] lowFreqTransMatrixCol32to47 =

[0686] {

[0687] {3 -1 0 0 2 -1 0 0 2 -1 0 0 1 0 0 0}

[0688] {-12 2 1 0 -5 1 0 0 -1 0 0 0 -2 0 0 0}

[0689] {17 -3 -1 0 6 -1 -1 0 2 0 0 0 2 0 0 0}

[0690] {-7 -1 2 0 -3 -1 1 0 -2 -2 1 0 0 0 0 0}

[0691] {-32 -3 3 0 12 -2 -1 0 7 0 0 0 1 0 0 0}

[0692] {-3 -19 3 0 -4 -6 1 0 0 0 0 0 0 -1 0 0}

[0693] {117 -10 -8 0 32 1 -4 0 3 1 -1 0 -3 1 0 0}

[0694] {-7 32 -5 1 -1 4 0 0 2 -1 0 0 1 0 -1 0}

[0695] {4 10 5-1 0 3 1 0-2 1 2 0 -1 1 1 0}

[0696] {30 13 -3 0 -116 6 10 0 -35 -5 4 0 -3 -1 0 0}

[0697] {-10 -63 1 2-17 3 -4 0 -1 9 -1 0 3 4 -1 0}

[0698] {2 -3 -4 0 2 -2 -2 0 0 0 -1 0 0 -1 -1 0}

[0699] {-8 -2 -1 1 30 4 -4 1-102 4 8 -1 -69 -2 6 -1}

[0700] {1 -95 18 -6 -10 -34 -2 0 -4 17 -2 0 0 2 1 0}

[0701] {2 10 24 -7 5 9 19 -1 0 1 4 0 -2 0 1 0}

[0702] {-1 -2 -4 4 0 3 1 -1 0 2 0 -2 2 0 0 0}

[0703] },

[0704] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 2, and lfnstIdx is equal to 2, then the following applies:

[0705] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0706] lowFreqTransMatrixCol0to15=

[0707] {

[0708] {87 -41 3 -4 1 -1 0 -1 -73 28 2 1 1 1 0 0}

[0709] {-75 4 7 0 2 0 1 0 -41 36 -7 3 -1 1 0 0}

[0710] {26 -44 22 -6 4 -2 1 -1 77 24 -22 2 -4 0 -1 0}

[0711] {-39 -68 37 -7 6 -2 2 0 -9 56 -21 1 -2 0 -1 0}

[0712] {10 -20 2 0 1 0 0 0 50 -1 8 -5 1 -1 0 0}

[0713] {-21 -45 8 -2 3 -1 1 0 -7 -30 26 -8 3 -1 1 -1}

[0714] {-4 -2 -55 28 -8 5 -3 2 -2 37 43 -19 1 -2 1 -1}

[0715] {2 19 47 -23 6 -4 2 -1 -23 -22 -44 17 -2 2 -1 0}

[0716] {-19 -62 -9 3 0 0 0 0 -12 -56 27 -7 3 -1 1 0}

[0717] {1 9 -5 0 -1 0 0 0 0 22 -1 2 0 1 0 0}

[0718] {5 17 -9 0 -2 10 0 13 54 -2 7 -1 1 0 0}

[0719] {7 27 56 -2 10 -3 3 -1 -2 -6 8 -28 3 -4 1 -1}

[0720] {0 0 19 -4 3 -2 2 -1 -3 -13 10 -4 1 0 0 0}

[0721] {-3 0 -27 -80 40 -16 6 -4 4 3 31 61 -22 7 -1 1}

[0722] {1 2 -8 6 -1 1 0 0 2 8 -5 -1 0 0 0 0}

[0723] {-4 -18 -57 8 -8 1 -3 0 -5 -20 -69 7 -6 2 -2 1}

[0724] }，

[0725] lowFreqTransMatrix[m][n] =

[0726] lowFreqTransMatrixCol16to31[m - 16][n], where m = 16..31, n = 0..15

[0727] lowFreqTransMatrixCol16to31 =

[0728] {

[0729] {30 -5 -6 1 -1 0 0 0 -8 -3 3 0 0 0 0 0}

[0730] {72 -29 -2 0 -1 0 -1 0 -37 6 7 -2 1 0 0 0}

[0731] {7 -38 10 0 1 0 0 0 -51 27 4 -3 2 -1 1 0}

[0732] {-45 4 -3 6 -1 2 0 1 49 -13 3 -3 -1 0 0 0 0}

[0733] {66 17 -24 4 -3 1 -1 0 13 -49 15 1 0 0 0 0}

[0734] {-9 69 -33 5 -2 0 -1 0 -44 -31 10 7 -2 2 0 1}

[0735] {-47 -34 -27 5 4 -1 1 0 -39 -2 27 4 -2 1 0 0}

[0736] {-33 3 22 -2 -4 1 -1 0 -58 -17 6 -6 7 -1 1 0}

[0737] {7 -8 16 -6 4 -2 1 -1 -15 54 -23 2 -1 0 0 0}

[0738] {-13 17 0 -2 0 -1 0 0 -46 -10 -10 4 -1 1 0 0}

[0739] {4 51 -3 -6 -1 -1 0 0 -20 6 -34 9 -2 2 -1 0}

[0740] {-1 -4 -68 35 -5 5 -2 1 0 35 43 -4 -6 1 -1 0}

[0741] {-6 -37 -18 -5 2 -2 1 -1 6 -6 -7 25 -6 4 -1 1}

[0742] {-4 -7 -26 -6 -10 6 -4 1 3 8 14 -18 15 -5 2 -1}

[0743] {1 24 3 5 -1 1 0 0 -3 12 6 -10 1 -1 0 0}

[0744] {1 4 0 33 -7 5 -2 1 0 -9 53 -22 3 -1 0 0}

[0745] },

[0746] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0747] lowFreqTransMatrixCol32to47 =

[0748] {

[0749] {3 2 -1 0 -2 -1 0 0 1 1 0 0 -1 0 0 0}

[0750] {12 3 -4 0 -3 -2 1 0 4 0 0 0 -1 0 0 0}

[0751] {31 -5 -8 3 -14 0 5 -1 6 1 -3 0 -4 -1 1 0}

[0752] {-19 2 0 0 5 1 1 0 -2 0 -1 0 1 0 0 0}

[0753] {-53 34 6 -5 30 -7 -11 3 -11 -2 5 1 4 2 -1 -1}

[0754] {49 7 2 -6 -23 -3 -2 2 9 4 0 0 -2 -1 -1 0}

[0755] {-11 32 -8 -7 27 -12 -6 6 -13 0 4 -3 3 -1 -2 1}

[0756] {-23 40 -2 5 43 -11 -8 -1 -18 -4 5 2 4 3 0 -1}

[0757] {-42 -25 4 6 34 8 2 -2 -15 -1 0 -1 3 2 0 1}

[0758] {-80 -27 20 -4 -66 23 -2 -2 20 -3 -2 3 -14 2 3 -1}

[0759] {16 -52 28 1 59 15 -8 -5 -28 -7 2 ​​2 10 3 0 -1}

[0760] {-14 -38 -12 -10 9 5 7 6 -9 7 -4 -3 4 -4 0 3}

[0761] {16 10 55 -24 15 46 -52 1 35 -43 10 12 -23 13 5 -8}

[0762] {-2 -4 -1 13 0 2 -4 -3 3 -1 2 1 -2 0 -2 -1}

[0763] {-9 -1 -25 10 45 -11 18 2 86 1 -13 -4 -65 -6 7 2}

[0764] {4 -27 -2 -9 5 36 -13 5 -7 -17 1 2 4 6 4 -1}

[0765] },

[0766] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 3, and lfnstIdx is equal to 1, the following applies:

[0767] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol0to15[m][n], where m=0..15, n=0..15

[0768] lowFreqTransMatrixCol0to15=

[0769] {

[0770] {-115 37 9 2 2 1 1 0 10 -29 8 0 1 0 1 0}

[0771] {15 51 -18 0 -3 0 -1 0-95 7 34 -3 5 -1 2 0}

[0772] {29 -22 16 -6 3 -2 1 -1 -4 -80 12 15 0 3 0 1}

[0773] {-36 -98 25 5 4 1 2 1 -59 11 -17 1 1 1 0 0}

[0774] {-6 18 3 -3 -1 0 0 0 -50 -5 -38 12 0 2 0 1}

[0775] {4 15 52 -13 5 -3 2 -1 -17 -45 16 24 -2 4 -1 2}

[0776] {-20 -7 -43 4 0 1 -1 1 -7 35 0 12 -4 1 -1 0}

[0777] {4 29 1 26 -5 4 -2 1 -17 -7 -73 6 6 2 1 1}

[0778] {12 13 10 2 -1 3 -1 1 17 -2 -46 12 7 0 2 0}

[0779] {5 20 90 -17 4 -3 2 -1 6 66 8 28 -7 3 -1 1}

[0780] {-3 -4 -34 -12 2 -1 -1 0 5 25 11 43 -10 4 -2 1}

[0781] {-1 -3 2 19 -2 4 -1 2 9 3 -35 22 11 1 2 0}

[0782] {10 -4 -6 12 5 1 1 0 11 -9 -12 -2 -7 0-1 0}

[0783] {4 6 14 53 -4 4 0 2 0 -1 -20 -13 3 2 -1 1}

[0784] {2 9 13 37 19 6 2 2 -9 -3 -9 -28 -20 -4 -3 -1}

[0785] {3 -3 12 84 -12 8 -2 3 6 13 50 -1 45 1 7 0}

[0786] },

[0787] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol16to31[m-16][n], where m=16..31, n=0..15

[0788] lowFreqTransMatrixCol16to31=

[0789] {

[0790] {23 -8 -8 1 -1 0 0 0 3 3 -2 -1 0 0 0 0}

[0791] {23 -47 1 6 0 1 0 1 8 5 -12 0-1 0 0 0}

[0792] {45 7 -59 7 -2 1 -1 0 -15 41 -3 -16 2 -3 0 -1}

[0793] {6 -13 7 -3 0 0 0 0 14 -4 -14 3 -1 0 0 0}

[0794] {3 67 -7 -40 3 -6 1 -3 -12 -13 65 -3 -10 0 -1 0}

[0795] {-87 -8 -14 7 8 1 2 0 23 -35 -6 -3 1 1 0 0}

[0796] {-51 -2 -57 5 15 0 4 0 7 39 5 -55 1 -7 1 -3}

[0797] {-5 21 -3 5 -1 -3 0 -1 -11 2 -52 -3 27 -2 5 0}

[0798] {16 -45 -9 -53 6 1 1 0 70 16 8 -4 -37 1 -7 0}

[0799] {29 5 -19 12 9 -1 1 0 -10 14 -1 -13 7 0 1 0}

[0800] {23 20 -40 12 21 -3 4 -1 25 -28 -10 5 8 6 0 2}

[0801] {-7 -65 -19 -22 11 4 2 1 -75 -18 3 -1 -10 2 0 1}

[0802] {33 -10 -4 18 18 -4 4 -1 28 -72 1 -49 15 2 2 1}

[0803] {-3 1 -5 35 -16 -6 -1 -2 46 29 13 21 37 -5 4 -1}

[0804] {1 18 9 28 24 6 2 2 -20 -5 -25 -33 -36 9 -2 2}

[0805] {-2 18 -22 -37 -13 14 0 3 1 -12 -3 2 -15 -8 1 -1}

[0806] }

[0807] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0808] lowFreqTransMatrixCol32to47 =

[0809] {

[0810] {4 0 0 -1 1 1 0 0 2 0 0 0 0 0 0 0}

[0811] {3 -3 1 -1 2 1 -2 0 1 -1 0 0 1 1 -1 0}

[0812] {1 0 7 -2 -3 6 1 -2 0 0 1 0 -1 2 0 -1}

[0813] {2 8 -3 -5 2 0 0 0 0 3 0 -1 1 0 0 0}

[0814] {9 -20 -5 22 -2 0 0 -1 2 -3 -2 3 -1 0 1 0}

[0815] {2 5-17 0 3 -1 -1 -5 0 1 -4 0 1 0 0 -2}

[0816] {1 -10 41 2 4 -3 -2 3 -1 -2 7 1 1 -1 -1 0}

[0817] {0 27 8 -58 2 -5 25 3 0 3 0-5 0 -2 7 0}

[0818] {-12 29 3 21 4 0 5 -1 -3 4 1 4 2 0 1 0}

[0819] {0 -6 13 -4 0 -4 1 5 0 -1 -1 1 0 -1 0 0}

[0820] {-4 21 -64 -8 -5 19 10 -48 3 -1 10 -3 0 4 3 -6}

[0821] {2 -35 -27 4 1 8 -17 -19 3 0 3 -6 0 2 -1 -2}

[0822] {56 -23 22 -1 4 -1 -15 26 6 4 -10 0 0 2 -3 2}

[0823] {-10 -53 -18 8 9 12 -41 -25 -2 2 13 -16 4 1 -5 1}

[0824] {-13 42 1 57 -22 -2 -25-28 5 6 19 -12 -5 -3 -2 4}

[0825] {19 14 -4 -12 -4 5 17 8 2 -4 -4 4 -2 2 1 0}

[0826] },

[0827] - Otherwise, if nTrS is equal to 48, lfnstTrSetIdx is equal to 3, and lfnstIdx is equal to 2, the following applies:

[0828] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol0to15[m][n], where m == 0..15, n = 0..15

[0829] lowFreqTransMatrixCol0to15 =

[0830] {

[0831] {109, -26, -8, -3, -2, -1, -1, 0, -50, 28, 2, 1, 0, 0, 0, 0}

[0832] {-39, 31, -5, 2, -1, 1, 0, 0, -95, 6, 18, 0, 4, 0, 1, 0}

[0833] {29, -3, -2, -2, 0, 0, 0, 0, 0, -419, 0, 2, 0, 1, 0}

[0834] {18, 96, -23, 2, -5, 1, -2, 0, -10, 6, 10, -2, 1, -1, 1, 0}

[0835] {-29, -60, 16, -2, 3, -1, 1, 0, -52, 9, -17, 5, -2, 1, -1, 1}

[0836] {-23, -5, -15, 5, -2, 1, -1, 1, 2, 79, -13, -4, -2, -1, -1, 0}

[0837] {-7, -3, 12, -3, 3, -1, 1, 0, -31, -62, 8, 7, 0, 2, 0, 1}

[0838] {1, -26, 5, 0, 1, 0, 1, 0, 24, -3, 43, -6, 4, -2, 1, -1}

[0839] {11, 14, 6, -3, 1, -1, 1, 0, 10, -7, -9, 3, -2, 1, -1, 0}

[0840] {-10, -11, -47, 3, -4, 1, -1, 0, 5, 28, 11, -2, -1, 0, 0, 0}

[0841] {-8, -24, -99, 11, -10, 3, -4, 1, -5, -3619, -26, 4, -5, 1, -2}

[0842] {-5, 1, -1, 0, 1, 0, 0, 0, -10, -14, -6, 8, 0, 1, 0, 0}

[0843] {1 12 -20 21 -4 5 -2 2 -5 -2 -75 9 -1 2 -1 1}

[0844] {2 -9 -18 8 -3 3 -1 1 3 -25 -62 -6 0 -2 0 -1}

[0845] {4 9 39 18 0 20 1 -6 -16 -22 -37 5 -5 1 -2}

[0846] {-7 -2 15 -6 1 -1 1 -1 -11 -3 22 -14 0 -2 1 -1}

[0847] },

[0848] lowFreqTransMatrix[m][n]=lowFreqTransMatrixCol16to31[m-16][n], where m=16..31, n=0..15

[0849] lowFreqTransMatrixCol16to31=

[0850] {

[0851] {-18 -8 6 0 1 0 1 0 6 -2 -3 0 0 0 0 0}

[0852] {32 -49 5 1 1 0 0 0 27 -1 -14 2 -2 1 -1 0}

[0853] {86 4 -33 2 -6 1 -2 0 -32 58 1 -7 0 -2 0 -1}

[0854] {-14 26 2 -4 1 -1 0 0 -43 -9 35 -2 4 -1 1 0}

[0855] {13 56 -2 -9 0 -2 0 -1 -34 -18 41 0 3 0 1 0}

[0856] {-9 1 5-1 1 0 0 0 -4 49 2 -14 1 -3 0 -1}

[0857] {-75 9 -45 5 -1 1 -1 0 14 35 0 -23 2 -5 1 -2}

[0858] {-7 -64 9 14 0 3 0 1 -12 -4 5 3 -1 1 0 0}

[0859] {22 21 1 -21 2 -4 1 -2 92 1 53 0 -9 1 -2 0}

[0860] {-12 -2 -38 2 0 1 0 0 16 38 11 -16 -1 -3 0 -2}

[0861] {0 25 41 5 -3 1 0 0 10 -5 -7 12 2 1 0 0}

[0862] {-17 -2 7 -5 3 -1 0 0 -16 13 3 31 -1 6 0 2}

[0863] {-1 -2 -16 -4 0 -1 0 0 -7 7 -31 0 3 0 0 0}

[0864] {-6 -61 14 -51 2 -6 0 -2 -19 0 40 -7 -17 0 -3 0}

[0865] {-5 15 63 9 -16 0 -3 0 18 42 -18 27 15 1 3 1}

[0866] {-18 -7 30 -9 -4 0 -1 0 -35 23 23 10 -17 1 -3 0}

[0867] },

[0868] lowFreqTransMatrix[m][n] = lowFreqTransMatrixCol32to47[m - 32][n], where m = 32..47, n = 0..15

[0869] lowFreqTransMatrixCol32to47 =

[0870] {

[0871] {-3 2 1 -1 0 0 0 0 -2 0 0 0 0 0 0 0}

[0872] {3 5 -3 -2 4 1 -1 -1 2 0 0 0 2 0 0 0}

[0873] {-14 -8 20 0 -2 -3 0 4 -1 -1 0 0 -1 1 0 0}

[0874] {14 -40 1 10 2 1 -10 1 2 -4 -1 -1 0 0 -1 0}

[0875] {19 -36 -10 13 3 6 -14 -1 3 1 -1 -3 1 1 -1 -1}

[0876] {-31 -14 56 -1 13 -37 -4 20 -2 2 -10 0 2 -4 0 -1}

[0877] {1 -8 32 -1 7 -12 -4 10 0 2 -6 -1 2 0 0 -2}

[0878] {8 -59 -3 26 14 6 -58 6 -5 17 -7 -18 3 3 -1 -5}

[0879] {-21 -11 1 40 -5 -4 -24 5 -4 5 -6 -5 0 0 0 -3}

[0880] {12 -9 -22 7 -8 60 4 -36 -6 -15 54 7 3 -7 -8 14}

[0881] {-1 1 9 -3 -3 -14 -3 12 2 4 -13 -2 -1 3 2 -4}

[0882] {-93 -15 -46 -3 23 -19 0 -47 8 4 8 3 2 3 0 0}

[0883] {4 11 -12 4 -12 14 -50 -1 -8 32 -4 -54 2 0 30 -15}

[0884] {13 -4 11 9 17 0 24 5 1 -12 4 28 0 0 -15 8}

[0885] {12 -34 9 -24 4 28 -2 4 -11 -4 30 2 5 -13 -4 18}

[0886] {-19 53 6 48 -65 12 -12 11 -8 -16 10 -21 -2 -12 6 2}

[0887] },

[0888] 8.7.4.4 Transformation process

[0889] The inputs to this process are:

[0890] - variable nTb S, specifies the horizontal sample size of the transformed samples,

[0891] - variable nonZero S, specifies the horizontal sample size of non-zero scaled transform coefficients,

[0892] - a list x[j] of scaled transform coefficients, where j = 0..nonZeroS-1,

[0893] -Transform the kernel type variable trType.

[0894] The output of this process is a list y[i] of transformed samples, where i=0..nTbS-1.

[0895] The transformation matrix derivation process as specified in Section 8.7.4.5 is called with the transform size nTbS and the transform kernel type trType as input, and the transformation matrix transMatrix as output.

[0896] Depending on the value of trType, the following applies: The list of transformed samples y[i], where i=0..nTbS-1, is derived as follows:

[0897] - If trType is equal to 0, the following transformation matrix multiplication applies:

[0898] Where i = 0..nTbS-1(8-983)

[0899] Otherwise (trType equals 1 or trType equals 2), the following transformation matrix multiplication applies:

[0900] Where i = 0..nTbS-1(8-984)

[0901] 8.7.4.5 Transformation Matrix Derivation Process

[0902] The inputs to this process are:

[0903] - variable nTbS, specifies the horizontal sample size of the scaled transform coefficients,

[0904] - Transform kernel type trType.

[0905] The output of this process is the transformation matrix transMatrix.

[0906] Based on trType and nTbs, the transformation matrix transMatrix is ​​derived as follows:

[0907] - If trType is equal to 0, the following applies:

[0908] transMatrix[m][n] = transMatrixCol0to15[m][n], where m = 0..15, n = 0..63 (8-985)

[0909] transMatrixCol0to15=(8-986)

[0910] {

[0911] {64 64 64 64 64 64 64 64 64 64 64 64 64 64 64}

[0912] {91 90 90 90 88 87 86 84 83 81 79 77 73 71 69 65}

[0913] {90 90 88 85 82 78 73 67 61 54 46 38 31 22 13 4}

[0914] {90 88 84 79 71 62 52 41 28 15 2 -11 -24 -37 -48 -59}

[0915] {90 87 80 70 57 43 25 9 -9 -25 -43 -57 -70 -80 -87 -90}

[0916] {90 84 73 59 41 20 -2 -24 -44 -62 -77 -86 -90 -90 -83 -71}

[0917] {90 82 67 46 22 -4 -31 -54 -73 -85 -90 -88 -78 -61 -38 -13}

[0918] {90 79 59 33 2 -28 -56 -77 -88 -90 -81 -62 -37 -7 24 52}

[0919] {89 75 50 18 -18 -50 -75 -89 -89 -75 -50 -18 18 50 75 89}

[0920] {88 71 41 2 -37 -69 -87 -90 -73 -44 -7 33 65 86 90 77}

[0921] {88 67 31 -13 -54 -82 -90 -78 -46 -4 38 73 90 85 61 22}

[0922] {87 62 20 -28 -69 -90 -84 -56 -11 37 73 90 81 48 2 -44}

[0923] {87 57 9 -43 -80 -90 -70 -25 25 70 90 80 43 -9 -57 -87}

[0924] {86 52 -2 -56 -87 -84 -48 7 59 88 83 44 -11 -62 -90 -81}

[0925] {85 46 -13 -67 -90 -73 -22 38 82 88 54 -4 -61 -90 -78 -31}

[0926] {84 41 -24 -77 -90 -56 7 65 91 69 11 -52 -88 -79 -28 37}

[0927] {83 36 -36 -83 -83 -36 36 83 83 36 -36 -83 -83 -36 36 83}

[0928] {83 28 -44 -88 -73 -11 59 91 62 -7 -71 -90 -48 24 81 84}

[0929] {82 22 -54 -90 -61 13 78 85 31 -46 -90 -67 4 73 88 38}

[0930] {81 15 -62 -90 -44 37 88 69 -7 -77 -84 -24 56 91 52 -28}

[0931] {80 9 -70 -87 -25 57 90 43 -43 -90 -57 25 87 70 -9 -80}

[0932] {79 2 -77 -81 -7 73 83 11 -71 -84 -15 69 86 20 -65-87}

[0933] {78 -4 -82 -73 13 85 67 -22-88 -61 31 90 54 -38 -90 -46}

[0934] {77 -11 -86 -62 33 90 44 -52 -90 -24 69 83 2 -81 -71 20}

[0935] {75 -18 -89 -50 50 89 18 -75 -75 18 89 50 -50 -89 -18 75}

[0936] {73 -24-90 -37 65 81 -11 -88 -48 56 86 2 -84 -59 44 90}

[0937] {73 -31 -90 -22 78 67 -38 -90 -13 82 61 -46 -88 -4 85 54}

[0938] {71 -37 -90 -7 86 48 -62 -79 24 91 20 -81 -59 52 84 -11}

[0939] {70 -43 -87 9 90 25 -80 -57 57 80 -25 -90 -9 87 43 -70}

[0940] {69 -48 -83 24 90 2 -90 -28 81 52 -65 -71 44 84 -20 -90}

[0941] {67 -54 -78 38 85 -22 -90 4 90 13 -88 -31 82 46 -73 -61}

[0942] {65 -59 -71 52 77 -44 -81 37 84 -28 -87 20 90 -11 -90 2}

[0943] {64 -64 -64 64 64 -64 -64 64 64 -64 -64 64 64 -64 -64 64}

[0944] {62 -69 -56 73 48 -79 -41 83 33 -86 -24 88 15 -90 -7 91}

[0945] {61 -73 -46 82 31 -88 -13 90 -4 -90 22 85-38 -78 54 67}

[0946] {59 -77 -37 87 11 -91 15 86 -41 -73 62 56 -79 -33 88 7}

[0947] {57 -80 -25 90 -9 -87 43 70 -70 -43 87 9 -90 25 80 -57}

[0948] {56 -83 -15 90 -28 -77 65 44 -87 -2 88 -41 -69 73 33 -90}

[0949] {54 -85 -4 88 -46 -61 82 13 -90 38 67 -78 -22 90 -31 -73}

[0950] {52 -87 7 83 -62 -41 90 -20 -77 71 28 -91 33 69 -79 -15}

[0951] {50 -89 18 75 -75 -18 89 -50 -50 89 -18 -75 75 18 -89 50}

[0952] {48 -90 28 65 -84 7 79 -73 -15 87 -59 -37 91 -41 -56 88}

[0953] {46 -90 38 54 -90 31 61 -88 22 67 -85 13 73 -82 4 78}

[0954] {44 -91 48 41 -90 52 37 -90 56 33 -90 59 28 -88 62 24}

[0955] {43 -90 57 25 -87 70 9 -80 80 -9 -70 87 -25 -57 90 -43}

[0956] {41 -90 65 11 -79 83 -20 -59 90 -48 -33 87 -71 -2 73 -86}

[0957] {38 -88 73 -4 -67 90 -46 -31 85 -78 13 61 -90 54 22 -82}

[0958] {37 -86 79 -20 -52 90 -69 2 65 -90 56 15 -77 87 -41 -33}

[0959] {36 -83 83 -36 -36 83 -83 36 36 -83 83 -36 -36 83 -83 36}

[0960] {33 -81 87 -48 -15 71 -90 62 -2 -59 90 -73 20 44 -86 83}

[0961] {31 -78 90 -61 4 54 -88 82 -38 -22 73 -90 67 -13 -46 85}

[0962] {28 -73 91 -71 24 33 -77 90 -69 20 37 -79 90 -65 15 41}

[0963] {25 -70 90 -80 43 9 -57 87 -87 57 -9 -43 80 -90 70 -25}

[0964] {24 -65 88 -86 59 -15 -33 71 -90 83 -52 7 41 -77 91 -79}

[0965] {22 -61 85 -90 73 -38 -4 46 -78 90 -82 54 -13 -31 67 -88}

[0966] {20 -56 81 -91 83 -59 24 15 -52 79 -90 84 -62 28 11 -48}

[0967] {18 -50 75-89 89 -75 50 -18 -18 50-75 89 -89 75 -50 18}

[0968] {15 -44 69 -84 91 -86 71 -48 20 11 -41 65 -83 90 -87 73}

[0969] {13 -38 61 -78 88 -90 85 -73 54 -31 4 22 -46 67 -82 90}

[0970] {11 -33 52 -69 81 -88 91 -87 79 -65 48 -28 7 15 -37 56}

[0971] {9 -25 43 -57 70 -80 87 -90 90 -87 80 -70 57 -43 25 -9}

[0972] {7 -20 33 -44 56 -65 73 -81 86 -90 91 -90 87 -83 77 -69}

[0973] {4 -13 22 -31 38 -46 54 -61 67 -73 78 -82 85 -88 90 -90}

[0974] {2 -7 11 -15 20 -24 28 -33 37 -41 44 -48 52 -56 59 -62}

[0975] },

[0976] transMatrix[m][n] = transMatrixCol16to31[m - 16][n], where m = 16..31, n = 0..63 (8 - 987)

[0977] transMatrixCol16to31 = (8 - 988)

[0978] {

[0979] {64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64}

[0980] {62 59 56 52 48 44 41 37 33 28 24 20 15 11 7 2}

[0981] {-4 -13 -22 -31 -38 -46 -54 -61 -67 -73 -78 -82 -85 -88 -90 -90}

[0982] {-69 -77 -83 -87 -90 -91 -90 -86 -81 -73 -65 -56 -44 -33 -20 -7}

[0983] {-90 -87 -80 -70 -57 -43 -25 -9 9 25 43 57 70 80 87 90}

[0984] {-56 -37 -15 7 28 48 65 79 87 91 88 81 69 52 33 11}

[0985] {13 38 61 78 88 90 85 73 54 31 4 -22 -46 -67 -82 -90}

[0986] {73 87 90 83 65 41 11 -20 -48 -71 -86 -91 -84 -69 -44 -15}

[0987] {89 75 50 18 -18 -50 -75 -89 -89 -75 -50 -18 18 50 75 89}

[0988] {48 11 -28 -62 -84 -90 -79 -52 -15 24 59 83 91 81 56 20}

[0989] {-22 -61 -85 -90 -73 -38 4 46 78 90 82 54 13 -31 -67 -88}

[0990] {-79 -91 -77 -41 7 52 83 90 71 33 -15 -59 -86 -88 -65 -24}

[0991] {-87 -57 -9 43 80 90 70 25 -25 -70 -90 -80 -43 9 57 87}

[0992] {-41 15 65 90 79 37 -20 -69 -90 -77 -33 24 71 91 73 28}

[0993] {31 78 90 61 4 -54 -88 -82 -38 22 73 90 67 13 -46 -85}

[0994] {83 86 44 -20 -73 -90 -59 2 62 90 71 15 -48 -87 -81 -33}

[0995] {83 36 -36 -83 -83 -36 36 83 83 36 -36 -83 -83 -36 36 83}

[0996] {33 -41 -87 -77 -15 56 90 65 -2 -69 -90 -52 20 79 86 37}

[0997] {-38 -88 -73 -4 67 90 46 -31 -85 -78 -13 61 90 54 -22 -82}

[0998] {-86 -73 -2 71 87 33 -48 -90 -59 20 83 79 11 -65 -90 -41}

[0999] {-80 -9 70 87 25 -57 -90 -43 43 90 57 -25 -87 -70 9 80}

[1000] {-24 62 88 28 -59 -90 -33 56 90 37 -52 -90 -41 48 91 44}

[1001] {46 90 38 -54 -90 -31 61 88 22 -67 -85 -13 73 82 4 -78}

[1002] {88 56 -41 -91 -37 59 87 15 -73 -79 7 84 65 -28 -90 -48}

[1003] {75 -18 -89 -50 50 89 18 -75 -75 18 89 50 -50 -89 -18 75}

[1004] {15 -79 -69 33 91 28 -71 -77 20 90 41 -62 -83 7 87 52}

[1005] {-54 -85 4 88 46 -61 -82 13 90 38 -67 -78 22 90 31 -73}

[1006] {-90 -33 73 69 -41 -88 -2 87 44 -65 -77 28 90 15 -83 -56}

[1007] {-70 43 87 -9 -90 -25 80 57 -57 -80 25 90 9 -87 -43 70}

[1008] {-7 88 33 -79 -56 62 73 -41 -86 15 91 11 -87 -37 77 59}

[1009] {61 73 -46 -82 31 88 -13 -90 -4 90 22 -85 -38 78 54 -67}

[1010] {91 7 -90 -15 88 24 -86 -33 83 41 -79 -48 73 56 -69 -62}

[1011] {64 -64 -64 64 64 -64 -64 64 64 -64 -64 64 64 -64 -64 64}

[1012] {-2 -90 11 90 -20 -87 28 84 -37 -81 44 77 -52 -71 59 65}

[1013] {-67 -54 78 38 -85 -22 90 4 -90 13 88 -31 -82 46 73 -61}

[1014] {-90 20 84 -44 -71 65 52 -81 -28 90 2 -90 24 83 -48 -69}

[1015] {-57 80 25 -90 9 87 -43 -70 70 43 -87 -9 90 -25 -80 57}

[1016] {11 84 -52 -59 81 20 -91 24 79 -62 -48 86 7 -90 37 71}

[1017] {73 31 -90 22 78 -67 -38 90 -13 -82 61 46 -88 4 85 -54}

[1018] {90 -44 -59 84 2 -86 56 48 -88 11 81 -65 -37 90 -24 -73}

[1019] {50 -89 18 75 -75 -18 89 -50 -50 89 -18 -75 75 18 -89 50}

[1020] {-20 -71 81 2 -83 69 24 -90 52 44 -90 33 62 -86 11 77}

[1021] {-78 -4 82 -73 -13 85 -67 -22 88 -61 -31 90 -54 -38 90 -46}

[1022] {-87 65 20 -86 69 15 -84 71 11 -83 73 7 -81 77 2 -79}

[1023] {-43 90 -57 -25 87 -70 -9 80 -80 9 70 -87 25 57 -90 43}

[1024] {28 52 -91 56 24 -84 77 -7 -69 88 -37 -44 90 -62 -15 81}

[1025] {82 -22 -54 90 -61 -13 78 -85 31 46 -90 67 4 -73 88 -38}

[1026] {84 -81 24 48 -90 71 -7 -62 91 -59 -11 73 -88 44 28 -83}

[1027] {36 -83 83 -36 -36 83 -83 36 36 -83 83 -36 -36 83 -83 36}

[1028] {-37 -28 79 -88 52 11 -69 91 -65 7 56 -90 77 -24 -41 84}

[1029] {-85 46 13 -67 90 -73 22 38 -82 88 -54 -4 61 -90 78 -31}

[1030] {-81 90 -62 11 44 -83 88 -59 7 48 -84 87 -56 2 52 -86}

[1031] {-25 70 -90 80 -43 -9 57 -87 87 -57 9 43 -80 90 -70 25}

[1032] {44 2 -48 81 -90 73 -37 -11 56 -84 90 -69 28 20 -62 87}

[1033] {88 -67 31 13 -54 82 -90 78 -46 4 38 -73 90 -85 61 -22}

[1034] {77 -90 86 -65 33 7 -44 73 -90 87 -69 37 2-41 71 -88}

[1035] {18 -50 75 -89 89 -75 50 -18 -18 50 -75 89 -89 75 -50 18}

[1036] {-52 24 7 -37 62 -81 90 -88 77 -56 28 2 -33 59 -79 90}

[1037] {-90 82 -67 46 -22 -4 31 -54 73 -85 90 -88 78 -61 38 -13}

[1038] {-71 83 -90 90 -86 77 -62 44 -24 2 20 -41 59 -73 84 -90}

[1039] {-9 25 -43 57 -70 80 -87 90 -90 87 -80 70 -57 43 -25 9}

[1040] {59 -48 37-24 11 2 -15 28 -41 52 -62 71 -79 84 -88 90}

[1041] {90 -90 88 -85 82 -78 73 -67 61 -54 46 -38 31 -22 13 -4}

[1042] {65 -69 71 -73 77 -79 81 -83 84 -86

[1043] 87 -88 90 -90 90 -91}

[1044] },

[1045] transMatrix[m][n]=(n&1?-1:1)*transMatrixCol16to31[47-m][n](8-989)

[1046] Where m = 32..47, n = 0..63

[1047] transMatrix[m][n]=(n&1?-1:1)*transMatrixCol0to15[63-m][n](8-990)

[1048] Where m = 48..63, n = 0..63

[1049] - Otherwise, if trType is equal to 1 and nTbs is equal to 4, the following applies:

[1050] transMatrix[m][n]=(8-991)

[1051] {

[1052] {29 55 74 84}

[1053] {74 74 0 -74}

[1054] {84 -29 -74 55}

[1055] {55 -84 74 -29}

[1056] },

[1057] - Otherwise, if trType is equal to 1 and nTbs is equal to 8, the following applies:

[1058] transMatrix[m][n]=(8-992)

[1059] {

[1060] {17 32 46 60 71 78 85 86}

[1061] {46 78 86 71 32 -17 -60 -85}

[1062] {71 85 32 -46 -86 -60 17 78}

[1063] {85 46 -60 -78 17 86 32 -71}

[1064] {86 -17 -85 32 78 -46 -71 60}

[1065] {78 -71 -17 85 -60 -32 86 -46}

[1066] {60 -86 71 -17 -46 85 -78 32}

[1067] {32 -60 78 -86 85 -71 46 -17}

[1068] }, - Otherwise, if trType is equal to 1 and nTbs is equal to 16, the following applies:

[1069] transMatrix[m][n]=(8-993)

[1070] {

[1071] {8 17 25 33 40 48 55 62 68 73 77 81 85 87 88 88}

[1072] {25 48 68 81 88 88 81 68 48 25 0 -25 -48 -68 -81 -88}

[1073] {40 73 88 85 62 25 -17 -55 -81 -88 -77 -48 -8 33 68 87}

[1074] {55 87 81 40 -17 -68 -88 -73 -25 33 77 88 62 8 -48 -85}

[1075] {68 88 48 -25 -81 -81 -25 48 88 68 0 -68 -88 -48 25 81}

[1076] {77 77 0 -77 -77 0 77 77 0 -77 -77 0 77 77 0 -77}

[1077] {85 55 -48 -87 -8 81 62 -40 -88 -17 77 68 -33 -88 -25 73}

[1078] {88 25 -81 -48 68 68 -48 -81 25 88 0 -88 -25 81 48 -68}

[1079] {88 -8 -88 17 87 -25 -85 33 81 -40 -77 48 73 -55 -68 62}

[1080] {87 -40 -68 73 33 -88 8 85 -48 -62 77 25 -88 17 81 -55}

[1081] {81 -68 -25 88 -48 -48 88 -25 -68 81 0 -81 68 25 -88 48}

[1082] {73 -85 25 55 -88 48 33 -87 68 8 -77 81 -17 -62 88 -40}

[1083] {62 -88 68 -8 -55 88 -73 17 48 -87 77 -25 -40 85 -81 33}

[1084] {48 -81 88 -68 25 25 -68 88 -81 48 0 -48 81 -88 68 -25}

[1085] {33 -62 81 -88 85 -68 40 -8 -25 55 -77 88 -87 73 -48 17}

[1086] {17 -33 48 -62 73 -81 87 -88 88 -85 77 -68 55 -40 25 -8}

[1087] }, - Otherwise, if trType is equal to 1 and nTbs is equal to 32, the following applies:

[1088] transMatrix[m][n] = transMatrixCol0to15[m][n], where m = 0..15, n = 0..15 (8-994)

[1089] transMatrixCol0to15=(8-995)

[1090] {

[1091] {4 9 13 17 21 26 30 34 38 42 46 50 53 56 60 63}

[1092] {13 26 38 50 60 68 77 82 86 89 90 88 85 80 74 66}

[1093] {21 42 60 74 84 89 89 84 74 60 42 21 0 -21 -42 -60}

[1094] {30 56 77 87 89 80 63 38 9 -21 -50 -72 -85 -90 -84 -68}

[1095] {38 68 86 88 74 46 9 -30 -63 -84 -90 -78 -53 -17 21 56}

[1096] {46 78 90 77 42 -4 -50 -80 -90 -74 -38 9 53 82 89 72}

[1097] {53 85 85 53 0 -53 -85 -85 -53 0 53 85 85 53 0 -53}

[1098] {60 89 74 21 -42 -84 -84 -42 21 74 89 60 0 -60 -89 -74}

[1099] {66 90 56 -13 -74 -87 -46 26 80 84 34 -38 -85 -78 -21 50}

[1100] {72 86 34 -46 -89 -63 13 78 82 21 -56 -90 -53 26 84 77}

[1101] {77 80 9 -72 -84 -17 66 86 26 -60 -88 -34 53 90 42 -46}

[1102] {80 72 -17 -86 -60 34 90 46 -50 -89 -30 63 85 13 -74 -78}

[1103] {84 60 -42 -89 -21 74 74 -21 -89 -42 60 84 0 -84 -60 42}

[1104] {86 46 -63 -78 21 90 26 -77 -66 42 87 4 -85 -50 60 80}

[1105] {88 30 -78 -56 60 77 -34 -87 4 89 26 -80 -53 63 74 -38}

[1106] {90 13 -87 -26 84 38 -78 -50 72 60 -63 -68 53 77 -42 -82}

[1107] },

[1108] transMatrix[m][n] = transMatrixCol16to31[m - 16][n], where m = 16..31, n = 0..15 (8 - 996)

[1109] transMatrixCol16to31 = (8 - 997)

[1110] {

[1111] {66 68 72 74 77 78 80 82 84 85 86 87 88 89 90 90}

[1112] {56 46 34 21 9 -4 -17 -30 -42 -53 -63 -72 -78 -84 -87 -90}

[1113] {-74 -84 -89 -89 -84 -74 -60 -42 -21 0 21 42 60 74 84 89}

[1114] {-46 -17 13 42 66 82 90 86 74 53 26 -4 -34 -60 -78 -88}

[1115] {80 90 82 60 26 -13 -50 -77 -89 -85 -66 -34 4 42 72 87}

[1116] {34 -13 -56 -84 -88 -68 -30 17 60 85 87 66 26 -21 -63 -86}

[1117] {-85 -85 -53 0 53 85 85 53 0 -53 -85 -85 -53 0 53 85}

[1118] {-21 42 84 84 42 -21 -74 -89 -60 0 60 89 74 21 -42 -84}

[1119] {88 72 9 -60 -90 -63 4 68 89 53 -17 -77 -86 -42 30 82}

[1120] {9 -66 -88 -42 38 87 68 -4 -74 -85 -30 50 90 60 -17 -80}

[1121] {-90 -50 38 89 56 -30 -87 -63 21 85 68 -13 -82 -74 4 78}

[1122] {4 82 68 -21 -87 -56 38 90 42 -53 -88 -26 66 84 9 -77}

[1123] {89 21 -74 -74 21 89 42 -60 -84 0 84 60 -42 -89 -21 74}

[1124] {-17 -90 -30 74 68 -38 -88 -9 84 53 -56 -82 13 89 34 -72}

[1125] {-86 9 90 21 -82 -50 66 72 -42 -85 13 90 17 -84 -46 68}

[1126] {30 86 -17 -89 4 90 9 -88 -21 85 34 -80 -46 74 56 -66}

[1127] },

[1128] - Otherwise, if trType is equal to 2 and nTbs is equal to 4, the following applies:

[1129] transMatrix[m][n]=(8-998)

[1130] {

[1131] {84 74 55 29}

[1132] {74 0 -74 -74}

[1133] {55 -74 -29 84}

[1134] {29 -74 84 -55}

[1135] }, - Otherwise, if trType is equal to 2 and nTbs is equal to 8, the following applies:

[1136] transMatrix[m][n]=(8-999)

[1137] {

[1138] {86 85 78 71 60 46 32 17}

[1139] {85 60 17 -32 -71 -86 -78 -46}

[1140] {78 17 -60 -86 -46 32 85 71}

[1141] {71 -32 -86 -17 78 60 -46 -85}

[1142] {60 -71 -46 78 32 -85 -17 86}

[1143] {46 -86 32 60 -85 17 71 -78}

[1144] {32 -78 85 -46 -17 71 -86 60}

[1145] {17 -46 71 -85 86 -78 60 -32}

[1146] }, - Otherwise, if trType is equal to 2 and nTbs is equal to 16, the following applies:

[1147] transMatrix[m][n]=(8-1000)

[1148] {

[1149] {88 88 87 85 81 77 73 68 62 55 48 40 33 25 17 8}

[1150] {88 81 68 48 25 0 -25 -48 -68 -81 -88 -88 -81 -68 -48 -25}

[1151] {87 68 33 -8 -48 -77 -88 -81 -55 -17 25 62 85 88 73 40}

[1152] {85 48 -8 -62 -88 -77 -33 25 73 88 68 17 -40 -81 -87 -55}

[1153] {81 25 -48 -88 -68 0 68 88 48 -25 -81 -81 -25 48 88 68}

[1154] {77 0 -77 -77 0 77 77 0 -77 -77 0 77 77 0 -77 -77}

[1155] {73 -25 -88 -33 68 77 -17 -88 -40 62 81 -8 -87 -48 55 85}

[1156] {68 -48 -81 25 88 0 -88 -25 81 48 -68 -68 48 81 -25 -88}

[1157] {62 -68 -55 73 48 -77 -40 81 33 -85 -25 87 17 -88 -8 88}

[1158] {55 -81 -17 88 -25 -77 62 48 -85 -8 88 -33 -73 68 40 -87}

[1159] {48 -88 25 68 -81 0 81 -68 -25 88 -48 -48 88 -25 -68 81}

[1160] {40 -88 62 17 -81 77 -8 -68 87 -33 -48 88 -55 -25 85 -73}

[1161] {33 -81 85 -40 -25 77 -87 48 17 -73 88 -55 -8 68 -88 62}

[1162] {25 -68 88 -81 48 0 -48 81 -88 68 -25 -25 68 -88 81 -48}

[1163] {17 -48 73 -87 88 -77 55 -25 -8 40 -68 85 -88 81 -62 33}

[1164] {8 -25 40 -55 68 -77 85 -88 88 -87 81 -73 62 -48 33 -17}

[1165] },

[1166] - Otherwise, if trType is equal to 2 and nTbs is equal to 32, the following applies:

[1167] transMatrix[m][n] = transMatrixCol0to15[m][n], where m = 0..15, n = 0..15 (8-1001)

[1168] transMatrixCol0to15=(8-1002)

[1169] {

[1170] {90 90 89 88 87 86 85 84 82 80 78 77 74 72 68 66}

[1171] {90 8784 78 72 63 53 42 30 17 4 -9 -21 -34 -46 -56}

[1172] {89 84 74 60 42 21 0 -21 -42 -60 -74 -84 -89 -89 -84 -74}

[1173] {88 78 60 34 4 -26 -53 -74 -86 -90 -82 -66 -42 -13 17 46}

[1174] {87 72 42 4 -34 -66 -85 -89 -77 -50 -13 26 60 82 90 80}

[1175] {86 63 21 -26 -66 -87 -85 -60 -17 30 68 88 84 56 13 -34}

[1176] {85 53 0 -53 -85 -85 -53 0 53 85 85 53 0 -53 -85 -85}

[1177] {84 42 -21 -74 -89 -60 0 60 89 74 21 -42 -84 -84 -42 21}

[1178] {82 30 -42 -86 -77 -17 53 89 68 4 -63 -90 -60 9 72 88}

[1179] {80 17 -60 -90 -50 30 85 74 4 -68 -87 -38 42 88 66 -9}

[1180] {78 4 -74 -82 -13 68 85 21 -63 -87 -30 56 89 38 -50 -90}

[1181] {77 -9 -84 -66 26 88 53 -42 -90 -38 56 87 21 -68 -82 -4}

[1182] {74 -21 -89 -42 60 84 0 -84 -60 42 89 21 -74 -74 21 89}

[1183] {72 -34 -89 -13 82 56 -53 -84 9 88 38 -68 -74 30 90 17}

[1184] {68 -46 -84 17 90 13 -85 -42 72 66 -50 -82 21 90 9 -86}

[1185] {66 -56 -74 46 80 -34 -85 21 88 -9 -90 -4 89 17 -86 -30}

[1186] },

[1187] transMatrix[m][n] = transMatrixCol16to31[m - 16][n], where m = 16..31, n = 0..15 (8 - 1003)

[1188] transMatrixCol16to31 = (8 - 1004)

[1189] {

[1190] {63 60 56 53 50 46 42 38 34 30 26 21 17 13 9 4}

[1191] {-66 -74 -80 -85 -88 -90 -89 -86 -82 -77 -68 -60 -50 -38 -26 -13}

[1192] {-60 -42 -21 0 21 42 60 74 84 89 89 84 74 60 42 21}

[1193] {68 84 90 85 72 50 21 -9 -38 -63 -80 -89 -87 -77 -56 -30}

[1194] {56 21 -17 -53 -78 -90 -84 -63 -30 9 46 74 88 86 68 38}

[1195] {-72 -89 -82 -53 -9 38 74 90 80 50 4 -42 -77 -90 -78 -46}

[1196] {-53 0 53 85 85 53 0 -53 -85 -85 -53 0 53 85 85 53}

[1197] {74 89 60 0 -60 -89 -74 -21 42 84 84 42 -21 -74 -89 -60}

[1198] {50 -21 -78 -85 -38 34 84 80 26 -46 -87 -74 -13 56 90 66}

[1199] {-77 -84 -26 53 90 56 -21 -82 -78 -13 63 89 46 -34 -86 -72}

[1200] {-46 42 90 53 -34 -88 -60 26 86 66 -17 -84 -72 9 80 77}

[1201] {78 74 -13 -85 -63 30 89 50 -46 -90 -34 60 86 17 -72-80}

[1202] {42 -60 -84 0 84 60 -42 -89 -21 74 74 -21 -89 -42 60 84}

[1203] {-80 -60 50 85 -4 -87 -42 66 77 -26 -90 -21 78 63 -46 -86}

[1204] {-38 74 63 -53 -80 26 89 4 -87 -34 77 60 -56 -78 30 88}

[1205] {82 42 -77 -53 68 63 -60 -72 50 78 -38 -84 26 87 -13 -90}

[1206] },

[1207] 3 Technical problems solved by some public technical solutions

[1208] 1. The current VVC design uses the width and height of the transform block to determine the number of bit shifts during transform and inverse transform, which may reduce processing accuracy.

[1209] 2. The current VVC design uses the width and height of the transform block to determine the number of bit shifts during quantization and dequantization, which may reduce processing accuracy.

[1210] 3. The current VVC quantization design may cause the quantization residual to exceed the 16-bit dynamic range for some block sizes, which reduces the encoding and decoding efficiency due to subsequent clipping to 16 bits.

[1211] 4. Currently, a left shift is applied to the transform skip to align the energy with the transform block, which may be unnecessary.

[1212] 4 List of Embodiment Examples and Techniques

[1213] The following list should be considered as an example to explain the overall concept. These embodiments should not be interpreted in a narrow sense. In addition, these items can be combined in any way.

[1214] In the following description, a transform skip block may denote a block to which transform is not applied (non-identity transform) or only identity transform is applied, such as a block with transform skip mode; a block with BDPCM mode, a block with transform and quantization bypass mode, a block with palette mode.

[1215] 1. For transform skip blocks, the scaling factors used in the conversion of decoded coefficients to residuals (eg, tsShift) may be independent of the block size.

[1216] a. In one example, the scaling factor is a constant

[1217] i. In one example, the scaling factor may be set to 1.

[1218] b. In one example, the scaling factor may depend on the internal bit depth

[1219] i. In one example, the scaling factor can be set to (15-internal_bit_depth)

[1220] c. In one example, the transform process of scaling the transform coefficients is not called and the output of the scaling process of the transform coefficients is the input to generate the intermediate residual samples, ie, there is no bit shifting.

[1221] 2. For a transform block, the number of bit shifts for dequantization may depend on the actual transform size (e.g.

[1222] The size of the zeroing region is not taken into account).

[1223] a. In one example, the number of bit shifts for dequantization may depend on the height of the actual transform, ie, nonZeroH as described in 2.1.3.

[1224] 3. For a transform block, the number of bit shifts for the inverse transform may depend on the transform block size and the actual transform size.

[1225] a. In one example, the number of bit shifts for the inverse transform may depend on the transform block size.

[1226] b. In one example, the number of bit shifts for the inverse transform may depend on the height of the transform block.

[1227] c. In one example, the number of bit shifts for the inverse transform may depend on the height of the actual transform.

[1228] d. In one example, the number of bit shifts for the inverse transform may depend on the actual transform size.

[1229] e. In one example, for blocks whose transform block size is different from the actual transform size, the number of bit shifts for the inverse transform may be different from those for blocks whose transform block size is equal to the actual transform size.

[1230] f. In one example, for blocks whose transform block height is different from the actual transform height, the number of bit shifts for the inverse transform may be different from those for blocks whose transform block height is equal to the actual transform height.

[1231] 4. For transform blocks, the number of bit shifts for dequantization may depend on the capped transform block size.

[1232] a. In one example, when the transform block size is equal to or greater than 32x32, the number of bit shifts for dequantization may be according to a 16x16 block size.

[1233] b. In one example, whether and / or how to apply an upper bounded transform block size may depend on a quantization parameter.

[1234] c. In one example, whether and / or how to apply an upper bounded transform block size may depend on whether the block width is an even multiple of the block height.

[1235] d. In one example, whether and / or how to apply an upper bounded transform block size may depend on whether the block height is an even multiple of the block width.

[1236] 5. If a lossless codec is used, the transform and / or quantization process may be applied without bit shifting.

[1237] a. In one example, a sequence / picture / sub-picture / slice / slice group / slice / brick / CTU row / CTU / CU / PU / TU / sub-block level flag may be added to the bitstream to indicate whether the current video unit is encoded or decoded by lossless codec.

[1238] i. In one example, if lossless codec is used, the corresponding lossless flag of the current video unit may be set equal to 1.

[1239] b. In one example, if a lossless codec is used, a reversible transform may be applied so that the encoded frame is bit-exact with the original frame.

[1240] i. In one example, the transform size of the lossless codec block may be fixed to MxN (such as M=N=4).

[1241] ii. In one example, the transform core of the lossless codec block may be the Walsh Hadamard transform.

[1242] iii. In one example, transform skipping can be used for lossless codec blocks.

[1243] c. In one example, if a lossless codec is used for the current video block, the scaling factor used in the conversion of decoded coefficients to residuals (eg, tsShift) may be set to 1 (eg, no scaling).

[1244] d. In one example, if a lossless codec is used for the current video block, the number of bit shifts for the inverse transform may be equal to 0 (eg, no bit shift).

[1245] e. In one example, if lossless codec is used for the current video block, the quantization parameter may be set to N (such as N=4, eg, no quantization).

[1246] f. In one example, if lossless codec is used for the current video block, the number of bit shifts for dequantization may be equal to 0 (eg, no bit shift).

[1247] 5. Embodiment

[1248] The following changes marked in bold italics and deletions enclosed in brackets {{}} are based on JVET-O2001-vE.

[1249] 5.1 Example #1

[1250] This embodiment reflects a change in the scaling factor of the transform skip block to make it independent of the block size.

[1251] 8.7.2 Scaling and Transformation Process

[1252] The inputs to this process are:

[1253] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[1254] - variable cIdx, specifies the color component of the current block,

[1255] - variable nTbW, specifies the transform block width,

[1256] -Variable nTbH, specifies the transform block height.

[1257] The output of this process is a (nTbW)x(nTbH) matrix of residual samples resSamples[x][y], where x=0..nTbW-1, y=0..nTbH-1.

[1258] The variables bitDepth, bdShift, and tsShift are exported as follows:

[1259] bitDepth=(cIdx==0)? BitDepthY:BitDepthC(8-942)

[1260] bdShift=Max(20-bitDepth, 0)(8-943)

[1261] tsShift=5+((Log2(nTbW)+Log2(nTbH)) / 2)(8-944)

[1262] The variable codedCIdx is exported as follows:

[1263] - If cIdx is equal to 0 or TuCResMode[xTbY][yTbY] is equal to 0, codedCIdx is set equal to cIdx.

[1264] Otherwise, if TuCResMode[xTbY][yTbY] is equal to 1 or 2, codedCIdx is set equal to 1.

[1265] Otherwise, codedCIdx is set equal to 2.

[1266] The variable cSign is set equal to (1-2*slice_joint_cbcr_sign_flag).

[1267] The (nTbW)x(nTbH) matrix of the residual sample points resSamples is derived as follows:

[1268] 1. The scaling process of the transform coefficients as specified in Section 8.7.3 is called using the transform block position (xTbY, yTbY), transform block width nTbW and transform block height nTbH, the color component variable cIdx set equal to codedCIdx, and the bit depth bitDepth of the current color component as input, and the output is the (nTbW)x(nTbH) matrix d of the scaled transform coefficients.

[1269] 2. The (nTbW)x(nTbH) matrix r of the residual samples is derived as follows:

[1270] - If transform_skip_flag[xTbY][yTbY] is equal to 1 and cIdx is equal to 0, the residual sample matrix value r[x][y], where x=0..nTbW-1, y=0..nTbH-1, is derived as follows:

[1271]

[1272] Otherwise (transform_skip_flag[xTbY][yTbY] is equal to 0 or cIdx is not equal to 0), the transform process for scaled transform coefficients as specified in Section 8.7.4.1 is called with the transform block position (xTbY, yTbY), transform block width nTbW and transform block height nTbH, color component variables cIdx and the (nTbW) x (nTbH) matrix d of scaled transform coefficients as input, and the output is the (nTbW) x (nTbH) matrix r of residual samples.

[1273] 8.7.3 Scaling of Transform Coefficients

[1274] …

[1275] The variables bdShift, rectNorm, and bdOffset are derived as follows:

[1276]

[1277]

[1278] bdShift=bitDepth+((rectNonTsFlag?1:0)+(8-956)

[1279] (Log2(nTbW)+Log2(nTbH)) / 2)-5+dep_quant_enabled_flag-bdOffset=(1<<bdShift)>>1(8-957)

[1280] 5.2 Example #2

[1281] This embodiment reflects a change to base the scaling process on the actual transform size rather than the transform block size.

[1282] 8.7.3 Scaling of Transform Coefficients

[1283] The inputs to this process are:

[1284] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[1285] - variable nTbW, specifies the transform block width,

[1286] - variable nTbH, specifies the transform block height,

[1287] - variable cIdx, specifies the color component of the current block,

[1288] -The variable bitDepth specifies the bit depth of the current color component.

[1289] The output of this process is a (nTbW)x(nTbH) matrix d of scaled transform coefficients with elements d[x][y].

[1290]

[1291]

[1292] The quantization parameter qP is derived as follows:

[1293] - If cIdx is equal to 0 and transform_skip_flag[xTbY][yTbY] is equal to 0, the following applies:

[1294] qP=Qp′ Y (8-950)

[1295] Otherwise, if cIdx is equal to 0 (and transform_skip_flag[xTbY][yTbY] is equal to 1), the following applies:

[1296] qP=Max(QpPrimeTsMin,Qp′ Y )(8-951)

[1297] Otherwise, if TuCResMode[xTbY][yTbY] is equal to 2, the following applies:

[1298] qP=Qp′ CbCr (8-952)

[1299] - Otherwise, if cIdx is equal to 1, the following applies:

[1300] qP=Qp′ Cb (8-953)

[1301] - Otherwise (cIdx equals 2), the following applies:

[1302] qP=Qp′ Cr (8-954)

[1303] The variable rectNonTsFlag is exported as follows:

[1304] rectNonTsFlag=(((Log2(nTbW)+Log2(nTbH))&1)==1&&(8-955)

[1305] transform_skip_flag[xTbY][yTbY]==0)

[1306] The variables bdShift, rectNorm, and bdOffset are derived as follows:

[1307] bdShift=bitDepth+((rectNonTsFlag?1:0)+(8-956)

[1308]

[1309] bled_flag

[1310] bdOffset=(1<<bdShift)>>1(8-957)

[1311] The list levelScale[][] is specified as levelScale[j][k] = {{40, 45, 51, 57, 64, 72}, {57, 64, 72, 80, 90, 102}}, where j = 0..1, k = 0..5.

[1312] The (nTbW)x(nTbH) matrix dz is set equal to the (nTbW)x(nTbH) matrix TransCoeffLevel[xTbY][yTbY][cIdx].

[1313] To derive the scaled transform coefficients d[x][y], where x = 0..nTbW-1, y = 0..nTbH-1, the following applies:

[1314] - The intermediate scaling factor m[x][y] is derived as follows:

[1315] - m[x][y] is set equal to 16 if one or more of the following conditions are true:

[1316] -sps_scaling_list_enabled_flag is equal to 0.

[1317] -transform_skip_flag[xTbY][yTbY] is equal to 1.

[1318] - Otherwise, the following applies:

[1319] m[x][y]=ScalingFactor[Log2(nTbW)][Log2(nTbH)][matrixId][x][y],

[1320] Where matrixId is specified as in Table 7-5 (8-958)

[1321] -The scaling factor 1s[x][y] is derived as follows:

[1322] - If dep_quant_enabled_flag is equal to 1, the following applies:

[1323] ls[x][y]=(m[x][y]*levelScale[rectNonTsFlag][(qP+1)%6])<<((qP+1) / 6)(8-959)

[1324] - Otherwise (dep_quant_enabled_flag is equal to 0), the following applies:

[1325] ls[x][y]=(m[x][y]*levelScale[rectNonTsFlag][qP%6])<<(qP / 6)(8-960)

[1326] -When BdpcmFlag[xTbY][yYbY] is equal to 1, dz[x][y] is modified as follows:

[1327] - If BdpcmDir[xTbY][yYbY] is equal to 0 and x is greater than 0, the following applies:

[1328] dz[x][y]=Clip3(CoeffMin,CoeffMax,dz[x-1][y]+dz[x][y])(8-961)

[1329] Otherwise, if BdpcmDir[xTbY][yYbY] is equal to 1 and y is greater than 0, the following applies:

[1330] dz[x][y]=Clip3(CoeffMin,CoeffMax,dz[x][y-1]+dz[x][y])(8-962)

[1331] -The value dnc[x][y] is derived as follows:

[1332] dnc[x][y]=(dz[x][y]*ls[x][y]+bdOffset)>>bdShift(8-963)

[1333] -The scaling transformation coefficients d[x][y] are derived as follows:

[1334] d[x][y]=Clip3(CoeffMin, CoeffMax, dnc[x][y])(8-964)

[1335] 5.3 Example #3

[1336] This embodiment reflects the change of making the inverse transform shift dependent on the actual transform size and transform block size.

[1337] 8.7.4 Scaling Transform Coefficients Transformation Process

[1338] 8.7.4.1 General

[1339] The inputs to this process are:

[1340] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[1341] - variable nTbW, specifies the width of the current transform block,

[1342] - variable nTbH, specifies the height of the current transform block,

[1343] - variable cIdx, specifies the color component of the current block,

[1344] - A (nTbW)x(nTbH) matrix d[x][y] of scaled transform coefficients, where x=0..nTbW-1, y=0..nTbH-1.

[1345] The output of this process is a (nTbW)x(nTbH) matrix r[x][y] of residual samples, where x=0..nTbW-1, y=0..nTbH-1.

[1346] When lfnst_idx[xTbY][yTbY] is not equal to 0 and both nTbW and nTbH are greater than or equal to 4, the following applies:

[1347] - The variables predModeIntra, nLfnstOutSize, log2LfnstSize, nLfnstSize, and nonZeroSize are derived as follows:

[1348] predModeIntra=(cIdx==0)? IntraPredModeY[xTbY][yTbY]: IntraPredModeC[xTbY][yTbY](8-965)

[1349] nLfnstOutSize=(nTbW>=8&&nTbH>=8)? 48:16(8-966)

[1350] log2LfnstSize=(nTbW>=8&&nTbH>=8)? 3:2(8-967)

[1351] nLfnstSize=1<<log2LfnstSize(8-968)

[1352] nonZeroSize=((nTbW==4&&nTbH==4)||(nTbW==8&&nTbH==8))? 8∶16(8-969)

[1353] - When intra_mip_flag[xTbComp][yTbComp] is equal to 1 and cIdx is equal to 0, predModeIntra is set equal to INTRA_PLANAR.

[1354] - When predModeIntra is equal to INTRA_LT_CCLM, INTRA_L_CCLM, or INTRA_T_CCLM, predModeIntra is set equal to IntraPredModeY[xTbY+nTbW / 2][yTbY+nTbH / 2].

[1355] - Invoke the wide angle intra prediction mode mapping process as specified in section 8.4.5.2.6 with: predModeIntra, nTbW, nTbH and cIdx as inputs, and modified predModeIntra as output.

[1356] - The values ​​of the list u[x], where x = 0..nonZeroSize-1, are derived as follows:

[1357] xC=DiagScanOrder[2][2][x][0](8-970)

[1358] yC=DiagScanOrder[2][2][x][1](8-971)

[1359] u[x]=d[xC][yC](8-972)

[1360] - The one-dimensional low-frequency non-separable transform process as specified in Section 8.7.4.2 is called with the input length nonZeroSize of the scaled transform coefficients, the transform output length nTrS set equal to nLfnstOutSize, the list u[x] of scaled non-zero transform coefficients where x=0..nonZeroSize-1, the intra prediction mode predModeIntra selected by the LFNST set, and the LFNST index lfnst_idx[xTbY][yTbY] selected by the transform in the selected LFNST set as input, and the list v[x] where x=0..nLfnstOutSize-1 as output.

[1361] - The matrix d[x][y], where x=0..nLfnstSize-1, y=0..nLfnstSize-1 is derived as follows:

[1362] - If predModeIntra is less than or equal to 34, the following applies:

[1363] d[x][y]=(y<4)? v[x+(y<<log2LfnstSize)]: (8-973)

[1364] ((x<4)?v[32+x+((y-4)<<2)]:d[x][y])

[1365] - Otherwise, the following applies:

[1366] d[x][y]=(x<4)? v[y+(x<<log2LfnstSize)]: (8-974)

[1367] ((y<4)?v[32+y+((x-4)<<2)]:d[x][y])

[1368] The variable implicitMtsEnabled is exported as follows:

[1369] - implicitMtsEnabled is set equal to 1 if sps_mts_enabled_flag is equal to 1 and one of the following conditions is true:

[1370] -IntraSubPartitionsSplitType is not equal to ISP_NOSPLIT

[1371] -cu_sbt_flag is equal to 1 and Max(nTbW, nTbH) is less than or equal to 32

[1372] -sps_explicit_mts_intraenabled_flag is equal to 0 and CuPredMode[0][xTbY][yTbY] is equal to MODE_INTRA and lfnst_idx[x0][y0] is equal to 0 and intra_mip_flag[x0][y0] is equal to 0

[1373] - Otherwise, implicitMtsEnabled is set equal to 0.

[1374] The variable trTypeHor that specifies the horizontal transformation kernel and the variable trTypeVer that specifies the vertical transformation kernel are derived as follows:

[1375] -If cIdx is greater than 0, trTypeHor and trTypeVer are set equal to 0.

[1376] Otherwise, if implicitMtsEnabled is equal to 1, the following applies:

[1377] - If IntraSubPartitionsSplitType is not equal to ISP_NO_SPLIT or sps_explicit_mts_intra_enabled_flag is equal to 0 and CuPredMode[0][xTbY][yTbY] is equal to MODE_INTRA, trTypeHor and trTypeVer are derived as follows:

[1378] trTypeHor=(nTbW>=4&&nTbW<=16)? 1:0(8-975)

[1379] trTypeVer=(nTbH>=4&&nTbH<=16)? 1:0(8-976)

[1380] - Otherwise (cu_sbt_flag is equal to 1), trTypeHor and trTypeVer specified in Table 8-15 depend on cu_sbt_horizontal_flag and cu_sbt_pos_flag.

[1381] - Otherwise, trTypeHor and trTypeVer specified in Table 8-14 depend on tu_mts_idx[xTbY][yTbY].

[1382] The variables nonZeroW and nonZeroH are derived as follows:

[1383] - If lfnst_idx[xTbY][yTbY] is not equal to 0 and nTbW is greater than or equal to 4 and nTbH is greater than or equal to 4, then the following applies:

[1384] nonZeroW=(nTbW==4||nTbH==4)? 4:8(8-977)

[1385] nonZeroH=(nTbW==4||nTbH==4)? 4:8(8-978)

[1386] - Otherwise, the following applies:

[1387] nonZeroW=Min(nTbW, (trTypeHor>0)?16:32)(8-979)

[1388] nonZeroH=Min(nTbH, (trTypeVer>0)?16:32)(8-980)

[1389] The (nTbW)x(nTbH) matrix r of the residual samples is derived as follows:

[1390] 5. When nTbH is greater than 1, each (vertical) column is transformed into e[x][y] (where x=0..nonZeroW-1, y=0..nTbH-1) by scaling the transform coefficients d[x][y] (where x=0..nonZeroW-1, y=0..nonZeroH-1) using the following one-dimensional transform process specified in calling section 8.7.4.4: for each column x=0..nonZeroW-1, the height nTbH of the transform block, the non-zero height nonZeroH of the scaled transform coefficients, the list d[x][y], where y=0..nonZeroH-1 and the transform type variable trType set equal to trTypeVer are taken as input, and the output is the list e[x][y], where y=0..nTbH-1.

[1391] 6. When both nTbH and nTbW are greater than 1, the intermediate sample value g[x][y], where x = 0..nonZeroW-1, y = 0..nTbH-1, is derived as follows:

[1392]

[1393] 7. When nTbW is greater than 1, each (horizontal) row of the resulting matrix g[x][y] (where x = 0..nonZeroW-1, y = 0...nTbH-1) is transformed into r[x][y] (where x = 0...nTbW-1, y = 0..nTbH-1) by using the following one-dimensional transformation process specified in section 8.7.4.4: for each row y = 0...nTbH-1, the width nTbW of the transform block, the non-zero width nonZeroW of the resulting matrix g[x][y], the list g[x][y], where x = 0..nonZeroW-1 and the transform type variable trType set equal to trTypeHor are taken as input, and the output is the list r[x][y], where y = 0..nTbW-1.

[1394] 8. When nTbW is equal to 1, r[x][y] is set equal to e[x][y], where x = 0..nTbW-1, y = 0..nTbH-1.

[1395] 8.7.2 Scaling and Transformation Process

[1396] The inputs to this process are:

[1397] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[1398] - variable cIdx, specifies the color component of the current block,

[1399] - variable nTbW, specifies the transform block width,

[1400] -Variable nTbH, specifies the transform block height.

[1401] The output of this process is a (nTbW)x(nTbH) matrix of residual samples resSamples[x][y], where x=0..nTbW-1, y=0..nTbH-1.

[1402] The variables bitDepth, bdShift, and tsShift are exported as follows:

[1403] bitDepth=(cIdx==0)? BitDepth Y :BitDepth C (8-942)

[1404]

[1405] 5.4 Example #4

[1406] This embodiment reflects the changes to bring the quantized residual within the range of 16 bits.

[1407] 8.7.3 Scaling of Transform Coefficients

[1408] The inputs to this process are:

[1409] - specifies the luma position (xTbY, yTbY) of the top left sample of the current luma transform block relative to the top left luma sample of the current picture,

[1410] - variable nTbW, specifies the transform block width,

[1411] - variable nTbH, specifies the transform block height, - variable cIdx, specifies the color component of the current block,

[1412] -The variable bitDepth specifies the bit depth of the current color component.

[1413] The output of this process is a (nTbW)x(nTbH) matrix d of scaled transform coefficients with elements d[x][y].

[1414] The quantization parameter qP is derived as follows:

[1415] - If cIdx is equal to 0 and transform_skip_flag[xTbY][yTbY] is equal to 0, the following applies:

[1416] qP=Qp′ Y (8-950)

[1417] Otherwise, if cIdx is equal to 0 (and transform_skip_flag[xTbY][yTbY] is equal to 1), the following applies:

[1418] qP=Max(QpPrimeTsMin,Qp′ Y )(8-951)

[1419] Otherwise, if TuCResMode[xTbY][yTbY] is equal to 2, the following applies:

[1420] qP=Qp′ CbCr (8-952)

[1421] - Otherwise, if cIdx is equal to 1, the following applies:

[1422] qP=Qp′ Cb (8-953)

[1423] - Otherwise (cIdx equals 2), the following applies:

[1424] qP=Qp′ Cr (8-954)

[1425] The variable rectNonTsFlag is exported as follows:

[1426] rectNonTsFlag=(((Log2(nTbW)+Log2(nTbH))&1)==1&&(8-955)

[1427] transform_skip_flag[xTbY][yTbY]==0)

[1428] The variables bdShift, rectNorm, and bdOffset are derived as follows:

[1429]

[1430] bdOffset=(1<<bdShift)>>1(8-957)

[1431] Figure 55 is a block diagram of an example video processing system 500 that may implement various techniques disclosed herein. Various implementations may include some or all of the components in system 500. System 500 may include an input 502 that receives video content. The video content may be received in a raw or uncompressed format (e.g., 8 or 10 bit multi-component pixel values), or may be received in a compressed or encoded format. Input 502 may represent a network interface, a peripheral bus interface, or a storage interface. Examples of network interfaces include wired interfaces (such as Ethernet, passive optical networks (PONs), etc.) and wireless interfaces (such as Wi-Fi or cellular interfaces).

[1432] System 500 may include a codec component 504 that can implement various codecs or encoding methods described in this document. Codec component 504 can reduce the average bit rate of the video from input 502 to the output of codec component 504 to generate a codec representation of the video. Therefore, codec technology is sometimes referred to as video compression or video transcoding technology. The output of codec component 504 can be stored or sent via the connected communication, as represented by component 506. The bitstream (or codec) representation of the storage or communication of the video received at input 502 can be used by component 508 to generate pixel values ​​or displayable video sent to display interface 510. The process of generating user-visible video from bitstream representation is sometimes referred to as video decompression. In addition, although some video processing operations are referred to as "codec" operations or tools, it should be understood that codec tools or operations are used at the encoder, and the corresponding decoding tools or operations of the reverse codec results will be performed by the decoder.

[1433] Examples of peripheral bus interfaces or display interfaces may include Universal Serial Bus (USB) or High Definition Multimedia Interface (HDMI) or DisplayPort, etc. Examples of storage interfaces include SATA (Serial Advanced Technology Attachment), PCI, IDE interfaces, etc. The techniques described in this document may be implemented in various electronic devices, such as mobile phones, laptop computers, smart phones, or other devices capable of performing digital data processing and / or video display.

[1434] Figure 6600 is a block diagram of a video processing device 600. The device 600 can be used to implement one or more of the methods described herein. The device 600 can be implemented as a smart phone, a tablet computer, a computer, an Internet of Things (IoT) receiver, etc. The device 600 may include one or more processors 602, one or more memories 604, and video processing hardware 606. The (one or more) processors 602 can be configured to implement one or more methods described in this document. The (one or more) memories 604 can be used to store data and code, which is used to implement the methods and techniques described herein. The video processing hardware 606 can be used to implement some of the techniques described in this document in hardware circuits. In some implementations, the hardware 606 can be at least partially or completely within the processor 602, such as within a graphics co-processor.

[1435] Figure 7 is a flow chart of an example method 700 for video processing. The method 700 includes, at operation 710, performing conversion between a current block of video and a bitstream representation of the video according to a rule specifying that a scaling operation of a transform codec mode applied to the current block is configured to be independent of a size of the current block.

[1436] Figure 8 8 is a flow chart of an example method 800 for video processing. The method 800 includes, at operation 810, performing conversion between a current block of video and a bitstream representation of the video according to a rule, the rule specifying that a dequantization process or a scaling operation of a transform codec mode applied to the current block is configured to be independent of the transform codec mode.

[1437] Fig. 9 is a flow chart of an example method 900 of video processing. The method 900 includes, at operation 910, determining, for conversion between a video including a current block and a bitstream representation of the video, that the conversion includes application of a transform to the current block.

[1438] The method 900 includes, at operation 920, performing a conversion based on determining such that a bit shifting operation of a scaling process of transform coefficients associated with the transform is based on whether the current block is encoded using a block-based differential pulse code modulation (BDPCM) mode.

[1439] Fig.10 1 is a flow chart of an example method 1000 of video processing. The method 1000 includes, at operation 1010, performing conversion between a video including a current block and a bitstream representation of the video such that a transform shift used when converting between residual coefficient values ​​of the current block and codec coefficients of the current block is based on whether the current block is coded using a block-based differential pulse codec modulation (BDPCM) mode.

[1440] Fig.11is a flow chart of an example method 1100 of video processing. The method 1100 includes, at operation 1110, determining whether the current block is encoded using a block-based differential pulse codec modulation (BDPCM) mode for conversion between a video including the current block and a bitstream representation of the video.

[1441] The method 1100 includes, at operation 1120 , performing conversion based on the determination such that a zoom list associated with the BDPCM mode is disabled.

[1442] Fig.12 is a flow chart of an example method 1200 of video processing. The method 1200 includes, at operation 1210, determining, for conversion between a video including a current block and a bitstream representation of the video, that the conversion is performed by disabling application of a transform to the current block.

[1443] The method 1200 includes, at operation 1220 , performing conversion based on the determination such that the conversion includes a dequantization process and the decoded coefficients are constrained to a range having a minimum value and a maximum value after the dequantization process.

[1444] Fig.13 is a flow chart of an example method 1300 of video processing. The method 1300 includes, at operation 1310, determining whether the current block is coded using a block-based differential pulse codec modulation mode for conversion between a video including the current block and a bitstream representation of the video.

[1445] The method 1300 includes, at operation 1320 , performing conversion based on the determination such that the conversion includes a dequantization process and the decoded coefficients are constrained to a first range having a minimum value and a maximum value after the dequantization process.

[1446] The following technical solutions can be implemented as preferred solutions in some embodiments.

[1447] 1. A method for video processing, comprising: performing a conversion between a current block of a video and a bitstream representation of the video according to a rule, wherein the rule specifies that a scaling operation of a transform codec mode applied to the current block is configured to be independent of the size of the current block.

[1448] 2. The method of claim 1, wherein the transform coding mode comprises a transform skip mode, and wherein the scaling operation comprises a scaling process of the transform coefficients associated with the transform coding mode.

[1449] 3. A method as in Option 2, wherein the scaling process includes a bit shifting operation, and wherein the bit shifting operation is independent of the size of the current block.

[1450] 4. A method as in Option 1, wherein the transform coding mode includes a block-based differential pulse codec modulation (BDPCM) mode, and wherein the scaling operation includes a scaling factor for converting between the residual coefficient value of the current block and the coding coefficient of the current block.

[1451] 5. The method of claim 4, wherein the scaling factor is a predefined constant.

[1452] 6. A method as in Option 5, wherein the scaling factor is one.

[1453] 7. The method of claim 4, wherein the scaling factor is based on an internal bit depth (ibd).

[1454] 8. A method as in Option 7, wherein the scaling factor is (15-ibd).

[1455] 9. The method of claim 4, wherein a transform process of scaling transform coefficients is disabled, and wherein an output of the transform coefficient scaling process is used as an input for generating intermediate residual samples.

[1456] 10. The method of claim 1, wherein the transform coding mode comprises a block-based differential pulse code modulation (BDPCM) mode, and wherein the scaling operation comprises a scaling process of the transform coefficients associated with the BDPCM mode.

[1457] 11. The method of scheme 10, wherein the scaling process includes a bit shifting operation, and wherein the bit shifting operation is independent of the size of the current block.

[1458] 12. A method for video processing, comprising: performing conversion between a current block of a video and a bitstream representation of the video according to a rule, wherein the rule specifies that a dequantization process or a scaling operation of a transform codec mode applied to the current block is configured to be independent of the transform codec mode.

[1459] 13. The method of scheme 12, wherein the transform coding mode comprises a transform skip mode, and wherein a dequantization factor of the dequantization process is independent of the transform coding mode.

[1460] 14. The method of claim 12, wherein the transform coding mode comprises a block-based differential pulse code modulation (BDPCM) mode, and wherein the dequantization factor of the dequantization is independent of the transform coding mode.

[1461] 15. The method of scheme 13 or 14, wherein the dequantization factor is expressed as levelScale.

[1462] 16. A method as described in Scheme 12, wherein the transform coding mode includes a transform skip mode, wherein the height of the current block is not equal to the width of the current block, wherein the scaling operation includes a scaling operation of transform coefficients, and wherein the bit shifting operation used in the scaling process is independent of the transform coding mode.

[1463] 17. A method as described in Scheme 12, wherein the transform coding mode includes a block-based differential pulse codec modulation (BDPCM) mode, wherein the height of the current block is not equal to the width of the current block, wherein the scaling operation includes a scaling operation of transform coefficients, and wherein the bit shifting operation used in the scaling process is independent of the transform coding mode.

[1464] 18. A method of video processing, comprising: determining that the conversion includes application of a transform to the current block for conversion between a video including a current block and a bitstream representation of the video, and performing the conversion based on the determination, wherein a bit shifting operation of a scaling process of transform coefficients associated with the transform is based on whether the current block is encoded and decoded using a block-based differential pulse codec modulation (BDPCM) mode.

[1465] 19. The method of scheme 18, wherein, when the current block is encoded and decoded using the BDPCM mode, a bit shifting operation of the current block is consistent with a bit shifting operation of a video block encoded and decoded using a transform skip mode.

[1466] 20. A method of video processing, comprising: performing a conversion between a video including a current block and a bitstream representation of the video, wherein a transform shift used when converting between residual coefficient values ​​of the current block and codec coefficients of the current block is based on whether the current block is encoded and decoded using a block-based differential pulse codec modulation (BDPCM) mode.

[1467] 21. The method of scheme 20, wherein, when the current block is encoded and decoded using the BDPCM mode, the transform shift of the current block is consistent with the transform shift of the video block encoded and decoded using the transform skip mode.

[1468] 22. A method of video processing, comprising: for conversion between a video including a current block and a bitstream representation of the video, determining that the current block is encoded and decoded using a block-based differential pulse codec modulation (BDPCM) mode, and performing the conversion based on the determination, wherein a scaling list associated with the BDPCM mode is disabled.

[1469] 23. The method of claim 22, wherein each entry in the scaling list is a predefined constant.

[1470] 24. A method as described in Scheme 23, wherein the predefined constant is 16.

[1471] 25. A method of video processing, comprising: for conversion between a video including a current block and a bitstream representation of the video, determining that the conversion is performed by disabling application of a transform to the current block, and performing the conversion based on the determination, wherein the conversion includes a dequantization process, and wherein after the dequantization process, the decoded coefficients are constrained to a range having a minimum value (TxMin) and a maximum value (TsMax).

[1472] 26. A method of video processing, comprising: for conversion between a video including a current block and a bitstream representation of the video, determining that the current block is encoded and decoded using a block-based differential pulse codec modulation (BDPCM) mode, and performing the conversion based on the determination, wherein the conversion includes a dequantization process, and wherein after the dequantization process, the decoded coefficients are constrained to a first range having a minimum value (BdpcmMin) and a maximum value (BdpcmMax).

[1473] 27. The method of claim 25 or 26, wherein the transform coefficients are constrained to a second range having a minimum value (CoeffMin) and a maximum value (CoeffMax).

[1474] 28. The method of scheme 25 or 26, wherein the minimum value is -(1<<bitDepth), and wherein bitDepth is the bit depth of the color component of the video to which the transform skip mode has been applied.

[1475] 29. The method of scheme 25 or 26, wherein the maximum value is [(1<<bitDepth)-1], and wherein bitDepth is the bit depth of the color component of the video to which the transform skip mode has been applied.

[1476] 30. The method of scheme 25 or 26, wherein the minimum value is -(1<<min(bitDepth, 15)), and wherein bitDepth is the bit depth of the color component of the video to which the transform skip mode has been applied.

[1477] 31. A method as in scheme 25 or 26, wherein the maximum value is [(1<<min(bitDepth, 15))-1], and wherein bitDepth is the bit depth of the color component of the video to which the transform skip mode has been applied.

[1478] 32. A method as in any one of schemes 1 to 31, wherein performing the conversion includes generating the bitstream representation from the current block.

[1479] 33. A method as described in any one of schemes 1 to 31, wherein performing the conversion includes generating the current block from the bitstream representation.

[1480] 34. A device in a video system, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method of any one of schemes 1 to 33.

[1481] 35. A computer program product stored on a non-transitory computer-readable medium, the computer program product comprising a program code for implementing the method of any one of schemes 1 to 33.

[1482] 36. A computer-readable medium storing the bitstream representation generated according to any one of the methods of schemes 1 to 33.

[1483] 37. A computer readable medium storing a codec representation or a bitstream representation generated according to any one of claims 1 to 33.

[1484] In the above schemes, performing the conversion includes using the results of previous decision steps (e.g., using or not using certain encoding or decoding steps) to reach the conversion results during the encoding or decoding operation. In the above schemes, video processing can include video encoding or encoding or compression or transcoding (changing from one format or bit rate to another format or bit rate), decoding or decompression. In addition, these schemes can be applied to other visual data such as images.

[1485] Other disclosed schemes, examples, embodiments, modules and functional operations described in this document can be implemented in digital electronic circuits or in computer software, firmware or hardware, including the structures disclosed in this document and the equivalent of their structures, or one or more combinations thereof. The disclosed and other embodiments can be implemented as one or more computer program products, for example, one or more computer program instruction modules encoded on a computer-readable medium, for execution by a data processing device or for controlling the operation of the data processing device. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a composite that affects a machine-readable propagable signal, or a combination of one or more thereof. The term "data processing device" covers all devices, equipment and machines for processing data, including, for example, a programmable processor, a computer or multiple processors or computers. In addition to hardware, the device can also include code that creates an execution environment for the computer program in question, for example, code that constitutes a processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them. A propagation signal is an artificially generated signal, such as a machine-generated electrical signal, an optical signal or an electromagnetic signal, which is generated to encode information for transmission to a suitable receiver device.

[1486] A computer program (also referred to as a program, software, software application, script or code) can be written in any form of programming language, including compiled or interpreted languages, and can be deployed in any form, including stand-alone programs or 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 in a portion of a file that stores other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple collaborative files (e.g., files storing one or more modules, subroutines or code portions). A computer program can be deployed to execute on one computer or on multiple computers, which are located at one site or distributed across multiple sites and interconnected by a communication network.

[1487] The processes and logic flows described in this document may be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows may also be performed by, and the device may be implemented as, a special purpose logic circuit such as an FPGA (field programmable gate matrix) or an ASIC (application specific integrated circuit).

[1488] Processors suitable for the execution of computer programs include, for example, both general-purpose and special-purpose microprocessors, and any one or more processors of any type of digital computer. Typically, the processor will receive instructions and data from a read-only memory or a random access memory or both. The basic elements of a computer are a processor for performing instructions and one or more storage devices for storing instructions and data. Typically, a computer will also include one or more mass storage devices (such as magnetic, magneto-optical disks or optical disks) for storing data, or operably coupled to receive data from a mass storage device (such as a magnetic, magneto-optical disk or optical disk) or transfer data to a mass storage device (such as a magnetic, magneto-optical disk or optical disk), or both. However, a computer does not have to have such a device. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including, by way of example, semiconductor memory devices (such as EPROM, EEPROM and flash memory devices), disks (such as internal hard disks or removable disks), magneto-optical disks, and CDROM and DVD-ROM disks. The processor and memory can be supplemented by dedicated logic circuits, or incorporated in dedicated logic circuits.

[1489] Although this patent document includes many details, these details should not be interpreted as limitations on any subject matter or the scope of protection that can be claimed, but as descriptions of features of specific embodiments of specific technologies. In this patent document, certain features described in the context of separate embodiments may also be implemented in combination in a single embodiment. On the contrary, the various features described in the context of a single embodiment may also be implemented in multiple embodiments, respectively, or in various suitable sub-combinations. In addition, although features may be described as working in certain combinations and even initially required in the same manner as described above, one or more features from the claimed combination may be removed from the combination in some cases, and the claimed combination may be directed to a sub-combination or a variation of the sub-combination.

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

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

Claims

1. A method for processing video data, comprising: Performing a conversion between a current block of a video and a bitstream of the video, wherein the conversion comprises: performing a scaling process of transform coefficients of the current block for deriving scaled transform coefficients of the current block according to a rule, wherein the rule specifies that in case a transform process of the scaled transform coefficients is skipped for the current block, a bit depth shift variable used in the scaling process is independent of a size of the current block, Wherein before the cropping operation, a bit depth offset and the bit depth shift variable are used to derive the scaled transform coefficients, and the bit depth offset is derived based on the bit depth shift variable.

2. The method according to claim 1, wherein: The bit depth shift variable bdShift1 is predefined.

3. The method according to claim 1, wherein: The rule further specifies that the bit depth shift variable and the bit depth offset are used in the scaling process in case the current block is coded in a Block-based Differential Pulse Codec Modulation (BDPCM) mode.

4. The method according to claim 1, wherein: The bit depth shift variable and the bit depth offset for a block coded in a block-based differential pulse codec modulation (BDPCM) mode are the same as the bit depth shift variable and the bit depth offset for a block in which a transform process of the scaled transform coefficients is skipped.

5. The method according to claim 1, wherein: The rule further specifies that, in the case where the current block is coded in the block-based differential pulse codec modulation (BDPCM) mode, explicit scaling matrices are disabled for the scaling process of transform coefficients of the current block.

6. The method according to claim 5, wherein: A flat scaling matrix is ​​used in the scaling process of the transform coefficients of the current block.

7. The method according to claim 6, wherein: The value of the flattened scaling matrix is ​​equal to 16.

8. The method according to claim 1, wherein: The scaling process includes a scaling operation or an inverse scaling operation, and the transform process includes a transform operation or an inverse transform operation.

9. The method according to claim 1, wherein: The converting includes encoding the current block into the bitstream.

10. The method according to claim 1, wherein: The converting includes decoding the current block from the bitstream.

11. An apparatus for processing video data, comprising a processor and a non-transitory memory having instructions thereon, wherein: When the instructions are executed by the processor, the processor: Performing a conversion between a current block of a video and a bitstream of the video, wherein the conversion comprises: performing a scaling process of transform coefficients of the current block for deriving scaled transform coefficients of the current block according to a rule, wherein the rule specifies that in case a transform process of the scaled transform coefficients is skipped for the current block, a bit depth shift variable used in the scaling process is independent of a size of the current block, Wherein before the cropping operation, a bit depth offset and the bit depth shift variable are used to derive the scaled transform coefficients, and the bit depth offset is derived based on the bit depth shift variable.

12. The device according to claim 11, wherein The bit depth shift variable bdShift1 is predefined.

13. The device according to claim 11, wherein: The rule further specifies that the bit depth shift variable and the bit depth offset are used in the scaling process in case the current block is coded in a Block-based Differential Pulse Codec Modulation (BDPCM) mode.

14. The device according to claim 11, wherein: The bit depth shift variable and the bit depth offset for a block coded in a block-based differential pulse codec modulation (BDPCM) mode are the same as the bit depth shift variable and the bit depth offset for a block in which a transform process of the scaled transform coefficients is skipped.

15. The device according to claim 11, wherein The rule further specifies that, in the case where the current block is coded in the block-based differential pulse codec modulation (BDPCM) mode, explicit scaling matrices are disabled for the scaling process of transform coefficients of the current block.

16. The device according to claim 11, wherein The scaling process includes a scaling operation or an inverse scaling operation, and the transform process includes a transform operation or an inverse transform operation.

17. A non-transitory computer-readable storage medium storing instructions for causing a processor to: Performing a conversion between a current block of a video and a bitstream of the video, wherein the conversion comprises: performing a scaling process of transform coefficients of the current block for deriving scaled transform coefficients of the current block according to a rule, wherein the rule specifies that in case a transform process of the scaled transform coefficients is skipped for the current block, a bit depth shift variable used in the scaling process is independent of a size of the current block, Wherein before the cropping operation, a bit depth offset and the bit depth shift variable are used to derive the scaled transform coefficients, and the bit depth offset is derived based on the bit depth shift variable.

18. The non-transitory computer-readable storage medium of claim 17, wherein the rule further specifies that the bit depth shift variable and the bit depth offset are used in the scaling process when the current block is encoded in a block-based differential pulse codec modulation (BDPCM) mode.

19. A method for storing a bit stream of a video, comprising: generating a bitstream of the video from a current block of the video, storing the bitstream in a non-transitory computer-readable storage medium, wherein the generating comprises: performing a scaling process of transform coefficients of the current block for deriving scaled transform coefficients of the current block according to a rule, wherein the rule specifies that in case a transform process of the scaled transform coefficients is skipped for the current block, a bit depth shift variable used in the scaling process is independent of a size of the current block, Wherein before the cropping operation, a bit depth offset and the bit depth shift variable are used to derive the scaled transform coefficients, and the bit depth offset is derived based on the bit depth shift variable.

20. The method for storing a bitstream of a video according to claim 19, wherein the rule further specifies that the bit depth shift variable and the bit depth offset are used in the scaling process when the current block is encoded in a block-based differential pulse codec modulation (BDPCM) mode.

21. A device in a video system, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor to implement the method of any one of claims 2 to 10.

22. A computer program product stored on a non-transitory computer readable medium, the computer program product comprising program code for carrying out the method of any one of claims 2 to 10.

Images