METHODS AND APPARATUS FOR SECONDARY TRANSFORM SIGNALING IN VIDEO CODING.

Abstract

A method for encoding and decoding video using Low Frequency Non-Separable Transform (LFNST) mode and apparatus is disclosed. The input data corresponds to primary transformed data in the encoder, and the input data corresponds to encoded data from the current CU in the decoder. A CU is partitioned into one or more transform blocks (TBs). An LFNST syntax is determined on one side of the encoder or one side of the decoder if one or more conditions are met. The LFNST syntax indicates whether the LFNST mode is applied to the current CU and / or which LFNST core is applied when the LFNST mode is applied. The conditions include CBF indications for the target TBs that are false. The current CU is encoded or decoded according to the LFNST mode as indicated by the LFNST syntax.

Description

METHODS AND APPARATUS FOR SECONDARY TRANSFORM SIGNALING IN VIDEO CODING Ln / zznz / E / YiAi CROSS REFERENCE TO RELATED APPLICATIONS The present invention claims priority to U.S. Provisional Patent Application, Serial Number 62 / 981,066, filed on February 25, 2020, and U.S. Provisional Patent Application, Serial Number 62 / 988,423, filed on March 12, 2020. The U.S. Provisional Patent Applications are incorporated herein by reference in their entirety. FIELD OF INVENTION The present invention relates to video coding. In particular, the present invention discloses a method and apparatus for signaling secondary transforms in order to improve performance. BACKGROUND OF THE INVENTION High Efficiency Video Coding (HEVC) is a new international video coding standard developed by the Joint Collaborative Team on Video Coding (JCT-VC). HEVC is based on a hybrid block-based motion-compensated DCT coding architecture. The basic unit for compression, called a coding unit (CU), is a 2Nx2N square block, and each CU can be recursively divided into four smaller CUs until a predefined minimum size is reached. Each CU contains one or more prediction units (PUs). To achieve the best coding efficiency of the hybrid coding architecture in HEVC, there are two types of prediction modes for each PU: intra-prediction and inter-prediction. For intra-prediction modes, reconstructed spatially neighboring pixels can be used to generate directional predictions. There are up to 35 directions in HEVC. For inter-prediction modes, reconstructed temporal reference frames can be used to generate motion-compensated predictions. There are three different modes, including Jump, Fusion, and Advanced Motion Vector Inter-Prediction (AMVP). Transformation process After prediction, the predicted residues for a CU are divided into transform units (TUs) and coded using transform and quantization. Like many other preceding standards, HEVC adopts the Discrete Cosine Transform type II (DCT-II) as its core transform (primary transform) because it has a strong energy compaction property. In order to improve the transform, the Transform of ίη / ζζηζ / E / γίΛΐ Discrete Sine Transform (DST) was introduced as an alternative to DCT for intra-oblique modes. For inter-predicted residuals, DCT-II is the only transform currently used in HEVC. However, DCT-II is not the optimal transform for all cases. Discrete Sine Transform type VII (DST-VII) and Discrete Cosine Transform type IVIII (DCT-VIII) are proposed to replace DCT-II in some cases. A multiple transform selection scheme (MTS) is also used for residual coding for intra- and inter-coded blocks. This scheme uses multiple transforms selected from DCT / DST families different from those currently used in HEVC. The recently introduced transform matrix is ​​DCT-VIII. In VVC, the multiple transform selection (MTS) for the kernel transform is described as follows. In addition to DCT-II which has been employed in HEVC, a Multiple Transform Selection (MTS) scheme is used for residual coding of inter and / or intra coded blocks. This uses multiple transforms selected from the DCT8 (DCTVIII) / DST7(DST-VII). The recently introduced transform matrices are DST-VII and DCT-VIII. The following table shows the basis functions of the selected DST / DCT. Table 1. Basis functions of transform of DCT-II / VI11 and DSTVII for N-point input Type of transform Basis function Ti(j), i, j = 0, 1,..., N-1 DCT-II 2 ίπ i (2 / + 1)\ Τ,ω = ω0· I -cos^ 2N JN xz where, ω0 = * = 0 ti ia 0 DCT-VIII Títf = λ 4 / π (2t + 1) (2 / + 1)\ 2N + 1 L°A 4N + 2 J DST-VII TíO) = Λ 4 . / π (2¿ + 1) ( / + 1)\ 2 / V+lk 2 / V +1 / In order to maintain the orthogonality of the transform matrix, the transform matrices are quantized more precisely than the transform matrices in HEVC. To keep the intermediate values ​​of the transformed coefficients within the 16-bit range, after the horizontal and vertical transforms, all coefficients are kept in 10 bits. To control the MTS scheme, separate enable indicators are Ln / zznz / E / YiAi are specified at the SPS level for intra- and inter-mode, respectively. When MTS is enabled in SPS, a CU level index is signaled to indicate the transform mode, specifying the transform types for the horizontal and vertical directions for the current CU. Here, MTS is applied only for luminance. The MTS CU level index (i.e., mtsjdx) can be signaled when both width and height are less than or equal to 32 and the CBF indicator is equal to one. If the MTS CU index is equal to zero, then DCT2 is applied in both directions. However, if the MTS CU index is greater than zero, the transform types for the horizontal and vertical directions are specified in Table 2. Table 2. Signaling and Transformation Mapping Table mts idx Intra / inter Horizontal Vertical 0 DCT2 1 DST7 DST7 2 DCT8 DST7 3 DST7 DCT8 4 DCT8 DCT8 To reduce the complexity of large-sized DST-7 and DCT-8, high-frequency transform coefficients are set to zero for DST-7 and DCT-8 blocks with a size (width or height, or both width and height) equal to 32. Only the coefficients within the lower 16x16 frequency region are retained. Low Frequency Non-Separable Transformer (LFNST) In VVC, the forward LFNST (low-frequency non-separable transform) 120, which is known as the reduced secondary transform, is applied between the forward primary transform 110 and quantization 130 (in the encoder), and the inverse LFNST 150 is applied between dequantization 140 and the inverse primary transform 160 (on the decoder side), as shown in FIGURE 1. In LFNST, a 4x4 non-separable transform or an 8x8 non-separable transform is applied according to the block size. For example, the 4x4 LFNST is applied for small blocks (i.e., min(width, height) < 8), and the 8x8 LFNST is applied for larger blocks (i.e., min(width, height) > 4). In FIGURE 1, the area filled with points 122 corresponds to 16 input coefficients for 4x4 advance LFNST or 48 input coefficients for 8x8 advance LFNST.The area filled with points 152 corresponds to 8 or 16 input coefficients for inverse 4x4 LFNST or 8 or 16 input coefficients for inverse 8x8 LFNST. The input to the primary forward transform is residuals of. Ln / zznz / E / YiAi prediction and the output of the inverse primary transform is the reconstructed residual in this case. The application of a non-separable transform, which is being used in LFNST, is described in the following example. To apply LFNST 4x4, the input block X 4x4, Yoo Yol ^02 Yq3 y _ -^10 Yll Y12 Y13 ^20 ^21 ^22 ^23 is first represented as a vector X: Ύ = [Χ00 X01 X02 X03 X10 X11 The non-separable transform is calculated as F = T - X, where F denotes the transform coefficient vector, and T is a 6x16 transform matrix. The 16x1 coefficient vector F is subsequently rearranged as a 4x4 block using the scan order for that block (i.e., horizontal, vertical, or diagonal). Coefficients with smaller indices will be placed with the smallest scan indices in the 4x4 coefficient block. Transformed Non-Separable Reduced LFNST (Low Frequency Non-Separable Transform) is based on a direct matrix multiplication approach to apply the non-separable transform, allowing it to be implemented in a single pass without multiple iterations. However, the matrix dimension of the non-separable transform needs to be reduced to minimize computational complexity and memory space for storing the transform coefficients. Therefore, a reduced non-separable transform (or RST) method is used in LFNST. The main idea behind the reduced non-separable transform is to map an N-dimensional vector to an R-dimensional vector in a different space, where N / R (R < N) is the reduction factor, and N is typically equal to 64 for 8x8 NSST (Secondary Non-Separable Transforms). Thus, instead of an NxN matrix, the RST matrix becomes an RxN matrix as follows: rr. U: fu T·· where the R rows of the transform are R bases of the N-dimensional space. The inverse transform matrix for RT is the transpose of its forward transform. For 8x8 LFNST, a reduction factor of 4 is applied. In this case, a 64x64 forward matrix, which is normally used for an 8x8 non-separable transform matrix, is reduced to a 16x48 forward matrix. Therefore, the 48x16 inverse RST matrix is ​​used on the decoder side to generate the kernel (primary) transform coefficients in the upper-left 8x8 region. When 16x48 matrices are applied instead of 16x64 with the same transform set configuration, each of which takes 48 input data from the three 4x4 blocks into an upper-left 8x8 block, excluding the lower-right 4x4 block. With the reduced size, the memory usage for storing all LFNST arrays is reduced from 10KB to 8KB with a reasonable performance drop. To reduce complexity, LFNST is restricted to being applicable only if all coefficients outside the first subgroup of coefficients are non-significant. Therefore, all coefficients of the primary-only transform must be set to zero when LFNST is applied. This allows for conditioning the LFNST index signaling at the last significant position. This avoids the need to scan extra coefficients in the current LFNST design, which is necessary to check for significant coefficients only at specific positions. The worst-case handling of LFNST, in terms of multiplications per pixel, restricts the non-separable transforms for 4x4 and 8x8 blocks to 8x16 and 8x48 transforms, respectively.In these cases, the last significant scan position must be less than 8 when applying LFNST for sizes other than 16. For blocks of a 4xN or Nx4 shape, where N ≥ 4, the proposed restriction implies that LFNST is applied only once and is applied to the upper-left 4x4 region only. For blocks of an 8xN or Nx8 shape, where N ≥ 8, the proposed restriction implies that LFNST is applied only once and is applied to the upper-left 8x8 region only. Because all primary-only coefficients are set to zero when LFNST is applied, the number of operations required for primary transforms is reduced in such cases. From the encoder's perspective, coefficient quantization is remarkably simplified when testing LFNST transforms.An optimized distortion-rate quantization must be performed at most for the first 8 or 16 coefficients in the scan order, and the remaining coefficients are forced to be zero. LFNST Transformer Selection There are a total of 4 transform sets and 2 non-separable transform matrices (kernels) per transform set in LFNST. The mapping from intra-prediction mode to transform set is predefined as shown in the following table. If one of the three CCLM (Cross-Component Linear Model) modes (i.e., INTRALTCCLM, INTRA T CCLM, or INTRA L CCLM) as indicated by 81 <= Ln / zznz / E / YiAi predModelntra <= 83) is used for the current block; transform set 0 or the intra prediction mode for luminance is selected for the current chrominance block. For each transform set, the selected non-separable secondary transform candidate (or named as non-separable transform metric) is further specified by the explicitly signaled LFNST index. The LFNST index is signaled in a bit stream once per Intra CU after the transform coefficients. Table 3. Transform selection table IntraPredMode Transform set 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 <= lntraPredMode<= 80 1 81 <= lntraPredMode<= 83 0 LFNST index signaling and interaction with other tools Because LFNST is restricted to being applicable only if all coefficients outside the first subgroup of coefficients are non-significant, the LFNST index coding (CU level) depends on the position of the last significant coefficient. Furthermore, the LFNST index is context-coded. However, the LFNST index is not dependent on the intra-prediction mode, and at least one bin is context-coded. Additionally, LFNST is applied for intra-CU in both intra- and inter-segment luminance and / or chrominance. If a dual tree is enabled, LFNST indices for luminance and chrominance are signaled separately. For inter-segment luminance (i.e., with the dual tree disabled), a single LFNST index is signaled and used for both luminance and / or chrominance. Considering that a large CU greater than 64x64 is implicitly tiled (TU in tiling) due to the existing maximum transform size restriction (i.e., 64x64 or set by configuration), an LFNST index search could increase data buffering by four times for a certain number of decoding pipeline stages. Therefore, the maximum size that the LFNST is allowed is restricted to 64x64 or the maximum transform size. Note that MTS is enabled only with LFNST disabled. As proposed in JVET-P0058 (T. Tsukuba, et al., “CE8-2.1: Transform Skip for Chroma with limiting maximum number of context-coded bin in TS residual coding,” ITU-T SG WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11, 16th Meeting: Geneva, OH, 1-11 October 2019, Document: JVET-P0058), this introduces transform hopping (TS) for chrominance and applies residual TS encoding to the transform hopping chrominance block. For example, TS is enabled for chrominance in all chrominance sampling formats. Furthermore, because BDPCM (block-based delta pulse-code modulation) uses TS, BDPCM can only be enabled when the TS enable condition is met. The TS enable condition contains a size constraint, meaning that the block width must be less than or equal to the maximum transform hopping size (MaxTsSize), and the block height must be less than or equal to MaxTsSize. If this condition is met, TS can be enabled.MaxTsSize is a fixed integer or a variable equal to 1 − (Iog2_transform_skip_max_size_minus + 2 ), where Iog2_transform_skip_max_size_minus specifies the maximum block size used for transform skip. Iog2_transform_skip_max_size_minus should be in the range of 0 to 3 and is inferred to be equal to 0 when not present. In VVC, the size restriction in TS for luminance is that if tbWidth <= MaxTsSize && tbHeight <= MaxTsSize, TS can be enabled. In VVC, the size restriction in TS for chrominance is that if wC <= MaxTsSize && hC <= MaxTsSize, TS can be enabled. In the aforementioned constraints, wC = tbWidth / SubWidthC and hC = tbHeight / SubHeightC. tbWidth is the block width for luminance, and tbHeight is the block height for luminance. The SubWidthC and SubHeightC variables are specified in the following table depending on the chrominance format sampling structure, which is specified through chroma_format_idc and separate_colour_plane_flag. Other values ​​for chroma_format_idc, SubWidthC, and SubHeightC may be specified in the future. Table 4. Specification of SubWidthC and SubHeightC Variables chroma_format_id c separate_colour_plane_fla g Chroma format SubWidthC SubHeightC 0 0 Monochrome 1 1 1 0 4:2:0 2 2 2 0 4:2:2 2 1 3 0 4:4:4 1 1 3 1 4:4:4 1 1 The detailed signaling condition for transform hop mode for each component is shown in the following table. Ln / zznz / E / YiAi Table 5. Signaling condition for transform jump mode for each component transform_unit( xO, yO, tbWidth, tbHeight, treeType, subTuIndex, chType ) { Descriptor s¡( IntraSubPartitionsSplltType != ISP_NO_SPLIT && treeType = = SINGLETREE && subTuIndex = = NumlntraSubPartitions - 1 ) { xC = CbPosX[ chType ][ xO ][ yO ] yC = CbPosY[ chType ][ xO ][ yO ] wC = CbWidth[ chType ][ xO ][ yO ] / SubWldthC hC = CbHeight[ chType ][ xO ][ yO ] / SubHeightC} además { xC = xO yC = yO wC = tbWidth / SubWldthC hC = tbHeight / SubHeightC} chromaAvailable = treeType != DUALTREELUMA && ChromaArrayType != 0 && (IntraSubPartitionsSplltType = = ISP_NO_SPLIT | | (IntraSubPartitionsSplltType != ISP_NO_SPLIT && subTuIndex = = NumlntraSubPartitions - 1 )) si( (treeType = = SINGLE_TREE | | treeType = = DUAL_TREE_CHROMA ) && ChromaArrayType != 0 ) { si( ( IntraSubPartitionsSplltType = = ISP_NO_SPLIT && !( cu_sbt_flag && (( subTuIndex = = 0 && cu_sbt_pos_flag ) | | ( subTuIndex = = 1 && !cu_sbt_pos_flag )))) | | (IntraSubPartitionsSplltType != ISP_NO_SPLIT && ( subTuIndex = =NumlntraSubPartitions - 1 ))) { tu_cbf_cb[ xC ][ yC ] ae(v) tu_cbf_cr[ xC ][ yC ] ae(v)}} S¡( treeType = = SINGLE TREE | | treeType = = DUAL TREE LUMA ) { si( (IntraSubPartitionsSplltType = = ISP_NO_SPLIT && !(cu_sbt_flag && (( subTuIndex = = 0 && cu_sbt_pos_flag ) | | ( subTuIndex = = 1 && !cu_sbt_pos_flag ))) && ( CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA | | ( chromaAvailable && (tu_cbf_cb[ xC ][ yC ] | | tu_cbf_cr[ xC ][ yC ])) | | CbWidth[ chType ][ xO ][ yO ] > MaxTbSizeY | | CbHeight[ chType ][ xO ][ yO ] > MaxTbSizeY )) | | (IntraSubPartitionsSplltType != ISP_NO_SPLIT && ( subTuIndex < NumlntraSubPartitions - 1 | | HnferTuCbfLuma ))) tu_cbf_luma[ xO ][ yO ] ae(v) si(lntraSubPartit¡onsSplitType != ISP_NO_SPLIT) InferTuCbfLuma = InferTuCbfLuma && !tu_cbf_luma[ xO ][ yO ] } s¡( ( CbWidth[ chType ][ xO ][ yO ] > 64 | | CbHeight[ chType ][ xO ][ yO ] > 64 | | tu_cbf_country[ xO ][ yO ] | | ( chromaAvailable && (tu_cbf_cb.[ xCb ] | xC ][ ])) && treeType != DUALTREECHROMA ) { s¡( cu_qp_delta_enabled_flag && HsCuQpDeltaCoded ) { cu_qp_delta_abs ae(v) s¡( cu_qp_delta_abs) cu_qp(delta) C¡e_sign_f chType ][ xO ][ yO ] > 64 |. CbHeight[ chType ][ xO ][ yO ] > 64 |. cu_chroma_qp_offset_enabled_flag && lIsCuChromaQpOffsetCoded) { cu_chroma_qp_offset_flag ae(v) s¡( cu_chroma_qp_offset_flag && chroma_qp_offset_listjen_chsen >_mx_cusnus ae(v)}} s¡( sps_Joint_cbcr_enabled_flag && (( CuPredMode[ chType ][ xO ][ yO ] = = MODEINTRA && (tu_cbf_cb[ xC ][ yC ] | | tu_cbf_cr[ xC ] ][ yC tu_cbf_cr[ xC ][ yC ])) && chromaAvailable) tujoint_cbcr_residual_flag[ xC ][ yC ] ae(v) s¡(tu_cbf_luma[ xO ][ yO ] && treeType != DUAL_TREE_CHROMA ) { s¡( sps_transform_skip_enabled_flag && !BdpcmFlag[ xO ][ yO ][ 0 ] && tbWidth <= MaxTsSize && tbHeight <= MaxTsSize && ( lntraSubPartitionsSpl¡t[ xO ][ yO ] == ISP NO SPLIT) && !cu_sbt_flag) transform_skip_flag[ xO ][ yO ][ 0 ] ae(v) s¡( !transform_skip_flag[ xO ][ yO ][ 0 ]) residual_coding( xO, yO, Log2( tbWidth ), Log2( tbHeight), 0 ) además residual_ts_coding( xO, yO, Log2( tbWidth ), Log2( tbHeight), 0 )} s¡( tu_cbf_cb[ xC ][ yC ] && treeType != DUAL TREE LUMA ) { s¡( sps_transform_skip_enabled_flag && !BdpcmFlag[ xO ][ yO ][ 1 ] && wC <= MaxTsSize && hC <= MaxTsSize && !cu_sbt_flag ) transform_skip_flag[ xC ][ yC ][ 1 ] ae(v) s¡( !transform_skip_flag[ xC ][ yC ][ 1 ]) residual_coding( xC, yC, Log2( wC ), Log2( hC ), 1 ) n«cn ίη / ζζηζ / Ε / γίΛΐ Ln / zznz / E / YiAi además residual_ts_coding( xC, yC, Log2( wC ), Log2( hC ), 1 )} s¡( tu_cbf_cr[ xC ][ yC ] && treeType != DUAL_TREE_LUMA && !(tu_cbf_cb[ xC ][ yC ] && tujoint_cbcr_residual_flag[ xC ][ yC ])) { s¡( sps_transform_skip_enabled_flag && !BdpcmFlag[ xO ][ yO ][ 2 ] && wC <= MaxTsSize && hC <= MaxTsSize && Icu sbt flag ) transform_skip_flag[ xC ][ yC ][ 2 ] ae(v) s¡( !transform_skip_flag[ xC ][ yC ][ 2 ]) residual_coding( xC, yC, Log2( wC ), Log2( hC ), 2 ) además residual_ts_coding( xC, yC, Log2( wC ), Log2( hC ), 2 )}} In the syntax table above, `transform_skip_flag[xO][yO][cldx]` specifies whether a transform is applied to the associated transform block. The array indices `xO` and `yO` specify the location (`xO`, `yO`) of the upper-left luminance sample of the considered transform block relative to the upper-left luminance sample of the image. The array index `cldx` specifies a flag for the color component; this is 0 for Y, 1 for Cb, and 2 for Cr. `transform_skip_flag[xO][yO][cldx]` equal to 1 specifies that no transform is applied to the associated transform block. `transform_skip_flag[xO][yO][cldx]` equal to 0 specifies that the decision as to whether the transform is applied to the associated transform block depends on other syntax elements. When transform_skip_flag[ xO ][ yO ][ cldx ] is not present, this is inferred as follows: If BdpcmFlag[ xO ][ yO ][ cldx ] is equal to 1, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred to be equal to 1. Otherwise (BdpcmFlag[ xO ][ yO ][ cldx ] is equal to 0), transform_skip_flag[ xO ][ yO ][ cldx ] is inferred as equal to 0. In the above, BdpcmFlag[ xO ][ yO ][ cldx ] is a variable corresponding to an intra BDPCM indicator for the luminance component (i.e., cldx = 0) or for the chrominance component (i.e., cldx = 1 or 2). BDPCM (Block DPCM) The older BDPCM method proposed in JVET-M0057 (“CE8: BDPCM with horizontal / vertical predictor and independently decodable areas (test 8.3.1b)”, JVET-M0057, ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC Joint Video Exploration Team (JVET) Ln / zznz / E / YiAi 29 / WG 11, Morocco, MA, January 2019) uses reconstructed samples to predict rows or columns line by line. The signaled BDPCM direction indicates whether vertical or horizontal prediction is used. The reference pixels used are unfiltered samples. The prediction error is quantified in the spatial domain. The pixels are reconstructed by adding the dequantized prediction error to the prediction. In JVET-N0413 (T. Tsukuba, et al., “CE8-2.1: Transform Skip for Chroma with limiting maximum number of context-coded bin in TS residual coding,” ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11 Joint Video Expert Team (JVET), 1-11 October 2019, Document: JVET-P0058), as an alternative scheme to the old BDPCM, quantized residual domain BDPCM, called RDPCM or BDPCM, is proposed. The signaling and prediction directions used are identical to the old BDPCM scheme as described in JVET-M0057 (F. Henry, et al., “CE8: BDPCM with horizontal / vertical predictor and independently decodable areas (test 8.3.1b)”, ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11 Joint Video Exploration Team (JVET), Morocco, MA, January 2019, Document: JVET-M0057).Intra-prediction for BDPCM is performed across the entire block per sample by copying in the prediction direction (horizontal or vertical prediction), similar to general intra-prediction. The residual is quantified, and the difference between the quantified residual and its quantified predictor value (horizontal or vertical) is coded. This can be described as follows. For a block of M (rows) χ N (columns), assume that rtj, 0 < i < Μ - 1, 0 <j < N — 1, sea el residual de predicción después de ejecutar intra predicción horizontalmente (es decir, copiando el valor de pixel vecino de izquierda a través del bloque predicho línea por línea) o verticalmente (es decir, copiando la línea vecina superior a cada línea en el bloque predicho) utilizando muestras no filtradas de las muestras de límite de bloque de arriba o izquierda. Asumir que Q(ri j), 0 < i < Μ - 1, 0 < j < N - 1, denota la versión cuantificada del residual r¡j, donde residual es la diferencia entre el bloque original y los valores de bloque predichos. La DPCM de bloque es entonces aplicada a las muestras residuales cuantificadas, teniendo como resultado un arreglo Μ χ N modificado R con elementos r^j. Cuando BDPCM vertical es señalizada, las muestras cuantificadas residuales son obtenidas a través de: ~ f ¿ = 0, 0 < j < (N — 1)riJ1 < i < (Μ — 1), 0 <j<(N-iy For horizontal prediction, similar rules apply, and the residual quantified samples are obtained through: ~ [ Q^, 0 <i<(M-l\j = 0 Ln / zznz / E / YiAi The residual quantified samples ñj are coded and sent to the decoder. On the decoder side, the above calculations are reversed to produce Qirij), 0 < i < M - 1, 0 < j < N -1. For the vertical prediction case, QK¡)=^=ofkj, 0 < t < (Μ — 1), 0 <j<(N-l). For the horizontal case, < i < (Μ — 1), 0 <j<(N-l). The inversely quantified residuals, Q-1, are added to the intra-prediction block values ​​to produce the reconstructed sample values. The RDPCM syntax is signaled at the CU / CB level. When the CU / CB is an intraluminance CU / CB and the CB width and / or height is less than or equal to a predefined threshold (e.g., 16, 32, 64, 128, 256, 512, or 1024), an indicator (e.g., bdpcmflag) is signaled to indicate whether RDPCM is enabled. If bdpcmflag is true, an additional indicator (bdpcm_dir_flag) is signaled to the prediction direction used in the RDPCM. For example, if bdpcm_dir_flag is 0, the horizontal direction is used; otherwise, if bdpcm_dir_flag is 1, the vertical direction is used. BDPCM can be applied to luminance and chrominance. The syntax table for BDPCM is shown in the following table. Further details can be found in JVET-N0413 (M. Karczewicz, et al., “CE8-related: Quantized residual BDPCM,” ITU-T Joint Video Expert Team (JVET) SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11, 14th Meeting: Geneva, CH, 19–27 March 2019, Documents: JVET-N0413). Table 6. Syntax table for BDPCM s¡( sps_bdpcm_enabled_flag && cbWidth <= MaxTsSize && cbHeight <= MaxTsSize ) intra_bdpcm_luma_flag ae(v) s¡( intra_bdpcm_luma_flag) intra_bdpcm_luma_dir_flag ae(v) si( cbWidth <= MaxTsSize && cbHeight <= MaxTsSize && sps_bdpcm_chroma_enabled_flag) { intra_bdpcm_chroma_flag ae(v) s¡( intra_bdpcm_chroma_flag ) intra_bdpcm_chroma_dir_flag ae(v)} also { VVC supports joint chrominance residual coding (JCCR) where chrominance residuals are jointly coded. The use (activation) of the mode Ln / zznz / E / YiAi JCCR is indicated by a TU level indicator, tujoint_cbcr_residual_flag, and the selected mode is implicitly indicated by the chrominance CBFs. The indicator, tujoint_cbcr_residual_flag, is present if either or both of the chrominance CBFs for a TU are equal to 1. In the PPS and segment header, chrominance QP offset values ​​are signaled for JCCR mode to differentiate them from the usual chrominance QP offset values ​​signaled for regular residual chrominance encoding mode. These chrominance QP offset values ​​are used to derive the chrominance QP values ​​for some blocks encoded using JCCR mode. JCCR mode has three sub-modes. When a corresponding JCCR sub-mode (sub-modes 2 in Table 7) is active in a TU, this QP chrominance compensation is added to the luminance-derived QP chrominance applied during the quantization and decoding of that TU.Table 7 corresponds to Table 3-13 of JVET-Q2002 (J. Chen, et al., “Algorithm description for Versatile Video Coding and Test Model 8 (VTM 8)”, ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11 Joint Video Expert Team (JVET), 17th Meeting: Brussels, BE, 7-17 January 2020, Document: JVET-Q2002). For the other JCCR sub-modes (sub-modes 1 and 3 in Table 7), the chrominance QPs are derived in the same way as for conventional Cb or Cr blocks. The process of reconstructing the chrominance residuals (resCb and resCr) of the transmitted transform blocks is shown in Table 7. When JCCR mode is activated, a single joint chrominance residual block (resJointC[x][y] in Table 7) is signaled, and the residual block for Cb (resCb) and the residual block for Cr (resCr) are derived considering information such as tu_cbf_cb, tu_cbf_cr, and CSign, which is a sign value specified in the segment header. On the encoder side, the joint chrominance components are derived as explained below. Depending on the mode (listed in the tables above), resJointC{1,2} are generated by the encoder as follows: If mode is equal to 2 (unique residual with reconstruction Cb = C, Cr = CSign * C), the joint residual is determined according to resJointC[ x ][ y ] = (resCb[ x ][ y ] + CSign * resCr[ x ][ y ]) / 2, Otherwise, if mode is equal to 1 (unique residual with reconstruction Cb = C, Cr = (CSign * C) / 2), the joint residual is determined according to resJointCj x ][ y ] = ( 4 * resCbj x ][ y ] + 2 * CSign * resCr[ x ][ y ]) / 5, Otherwise (mode equals 3, i.e., single residual, reconstruction Cr = C, Cb = (CSign * C) / 2), the joint residual is determined according to resJointC[ x ][ y ] = ( 4 * resCr[ x ][ y ] + 2 * CSign * resCb[ x ][ y ]) / 5. Chrominance residual reconstruction. The CSign value is a sign value (+1 or Ln / zznz / E / YiAi -1), which is specified in the segment header, resJointC[ ][ ] is the transmitted residual. Table 7. Syntax table for BDPCM tu_cbf_cb tu_cbf_cr Reconstruction of Cb and Cr residuals Mode 1 0 resCb[ x ][ y ] = resJointC[ x ][ y ] resCr[ x ][ y ] = ( CSign * resJointC[ x ][ y ]) » 1 1 1 1 resCb[ x ][ y ] = resJointC[ x ][ y ] resCr[ x ][ y ] = CSign * resJointC[ x ][ y ] 2 0 1 resCb[ x ][ y ] = (CSign * resJointC[ x ][ y ]) » 1 resCr[ x ][ y ] = resJointC[ x ][ y ] 3 The three joint chrominance encoding sub-modes described above in Table 7 are only supported in I segments. In P and B segments, only mode 2 is supported. Therefore, in P and B segments, the syntax element tujoint_cbcr_residual_flag is only present if both cbfs chrominance values ​​are 1. The JCCR mode can be combined with the chrominance transform hopping (TS) mode. To expedite the encoder's decision, the JCCR transform selection depends on whether the independent coding of Cb and Cr components selects DCT-2 or TS as the best transform, and whether there are non-zero coefficients in the independent chrominance coding. Specifically, if one chrominance component selects DCT-2 (or TS) and the other component is all zero, or both chrominance components select DCT-2 (or TS), then only DCT-2 (or TS) will be considered in the JCCR coding. Otherwise, if one component selects DCT-2 and the other selects TS, then both DCT-2 and TS will be considered in the JCCR coding. Further details can be found in JVET-N0054 (J.Lainema, “CE7: Joint coding of chrominance residuals (CE7-1),” Equipo Conjunto de Expertos en Video (JVET) de ITU-T SG 16 WP 3 e ISO / IEC JTC 1 / SC 29 / WG 11,14ava Reunión: Ginebra, CH, 19-27 de marzo 2019, Documentos: JVET-N0413). Intra sub-particiones (ISP) en VVC Intra-partitioning (ISP) blocks divide intra-predicted luminance blocks vertically or horizontally into 2 or 4 sub-partitions depending on the block size. For example, the minimum block size for ISP to divide a block is 4x8 (or 8x4). If the block size is larger than 4x8 (or 8x4), then the corresponding block is divided into 4 sub-partitions. It has been observed that ISP blocks of M x 128 (with M < 64) and M x 128 (with N < 64) could cause a potential problem with the 64x64 VDPU. For example, an M x 128 CU in the single-tree case has one luminance TB of M x 128 and two corresponding chrominance TBs of (M / 2)x64. If the CU uses ISP, then the luminance TB will be divided into four TB M x 32 (only horizontal division is possible), each smaller than a 64x64 block. However, in the current ISP design, the chrominance blocks are not divided. Therefore, both chrominance components will be larger than a 32x32 block.Similarly, a similar situation could be created with a 126 x N CU using ISP. Therefore, these two cases pose a problem for the 64x64 decoder pipeline. For this reason, CU sizes that can use ISP are restricted to a maximum of 64x64. Figures 2A and 2B show examples of the two possibilities. All sub-partitions meet the condition of having at least 16 samples. Figure 2A illustrates the case for block sizes of 4x8 or 8x4. In this case, block 210 is divided horizontally into two sub-blocks 220 or vertically into two sub-blocks 230. Figure 2B illustrates the case for block sizes other than 4x8 and 8x4. In this case, block 240 is partitioned horizontally into four sub-blocks 250 or vertically into four sub-blocks 260. In ISP, the reliance of 1xN or 2xN subblock predictions on reconstructed values ​​from previously decoded 1xN or 2xN subblocks of the encoding block is not permitted, so the minimum prediction width for subblocks becomes four samples. For example, an 8xN (N > 4) encoding block encoded using vertically split ISP is divided into two prediction regions, each 4xN in size, and four 2xN transforms are used. Similarly, a 4xN encoding block encoded using vertically split ISP is predicted using the entire 4xN block; four 1xN transforms are used. Although 1xN and 2xN transform sizes are permitted, it is stated that the transform of these blocks into 4xN regions can be executed in parallel.For example, when a 4xN prediction region contains four 1xN transforms, there is no transform in the horizontal direction; the transform in the vertical direction can be performed as a single 4xN transform in the vertical direction. Similarly, when a 4xN prediction region contains two 2xN transform blocks, the transform operation of the two 2xN blocks in each direction (horizontal and vertical) can be conducted in parallel. Therefore, there is no added delay in processing these smaller blocks compared to processing regular 4x4 intra-coded blocks. For each sub-partition, reconstructed samples are obtained by adding the residual signal to the prediction signal. Here, a residual signal is generated through processes such as entropic decoding, inverse quantization, and inverse transform. Therefore, the reconstructed sample values ​​of each sub-partition are available to generate the prediction for the next sub-partition, and each sub-partition is processed repeatedly. Furthermore, the first sub-partition to be processed is the one containing the upper-left sample of the CU, and then proceeding downwards (horizontal division) or to the right. Ln / zznz / E / YiAi (vertical split). As a result, reference samples used to generate the sub-partition prediction signals are located only on the left sides and above the lines. All sub-partitions share the same intra-mode. The following is a summary of ISP's interaction with other encoding tools. - Multiple Reference Line (MRL): If a block has an MRL index other than 0, then the ISP encoding mode will be inferred as 0 and therefore the ISP mode information will not be sent to the decoder. - Entropic coding coefficient group size: The sizes of the entropic coding subblocks have been modified so that they have 16 samples in all possible cases, as shown in Table 8. Note that the new sizes only affect blocks produced by ISP in which one of the dimensions is less than 4 samples. In all other cases, the coefficient groups maintain the 4x4 dimensions. - Coding CBF: It is assumed that at least one of the sub-partitions has a non-zero CBF. Therefore, if n is the number of sub-partitions and the first η - 1 sub-partitions have produced a zero CBF, then the CBF of the nth sub-partition is inferred to be 1. - MPM usage: the MPM indicator will be inferred to be one in a block encoded by ISP mode, and the MPM list is modified to exclude DC mode and prioritize horizontal intra-modes for vertical intra-modes and horizontal split ISP for that vertical. - Transform size restriction: all ISP transforms with a length longer than 16 points use DCT-II. - PDPC: When a CU uses ISP encoding mode, PDPC filters will not be applied to the resulting sub-partitions. - MTS Indicator: If a CU uses ISP encoding mode, the MTS CU indicator will be set to 0 and will not be sent to the decoder. Therefore, the encoder will not perform RD tests for the different transforms available for each resulting sub-partition. The transform choice for ISP mode will instead be fixed and selected according to the intra-mode, processing order, and block size used. Therefore, no signaling is required. For example, assume that tHy and tv are the horizontal and vertical transforms respectively selected for the sub-partition iv x L, where w is the width and h is the height. Then, the transform is selected according to the following rules: If w = 1 or oh = 1, then there is no horizontal or vertical transform respectively. If w = 2 ow > 32, tH= DCT-II If h = 2 oh > 32, tv= DCT-II Ln / zznz / E / YiAi In another way, the transformation is selected as in Table 9. Table 8. Entropic coding coefficient group size Block size Coeficient group size ΙχΝ,Ν > 16 1 x 16 Nxl.N > 16 16 x 1 2 ΧΝ,Ν > 8 2x8 N x 2,N > 8 8x2 All other possible cases M xN 4x4 Table 9. The selection of transformation depends on the mode Intra way you tv Plano Ang. 31,32,34,36,37 DST-VII DST-VII DC Ang.33,35 DCT-II DCT-II Ang.2, 4, 6...28,30 Ang. 39,41,43...63,65 DST-VII DCT-II Ang. 3,5,7...27,29 Ang. 38,40,42...64,66 DCT-II DST-VII In ISP mode, all 67 intra-modes are permitted. PDPC is also applied if the corresponding width and height are at least 4 samples long. Furthermore, the condition for intra-interpolation filter selection no longer exists, and the Cubic filter (DCT-IF) is always applied for fractional position interpolation in ISP mode. Further details can be found in JVET-M0102 (S. De-Luxán-Hernández, et al., “CE3: Intra Sub-Partitions Coding Mode (Tests 1.1.1 and 1.1.2)”, ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11 Joint Video Expert Team (JVET), 13th Meeting: Morocco, MA, 9–18 January 2019, Document: JVET-M0102). “Block” in this proposal can be TB / TU / PU / PB / CB / CU. BRIEF DESCRIPTION OF THE INVENTION A method and apparatus for video encoding and decoding using Low Frequency Non-Separable Transform (LFNST) mode is disclosed. According to the present invention, in the decoding process, input data related to a current encoding unit (CU) in a current image is received, where the current CU is partitioned into one or more transform blocks (TBs), and the input data corresponds to encoded data from the current CU. One or more Encoded Block Indicator (CBF) readings for one or more target TBs are checked against the encoded data. An LFNST syntax is analyzed if one or more conditions are met. The LFNST syntax indicates whether the LFNST mode is applied to the current CU and / or which LFNST kernel is applied if the LFNST mode is applied. The conditions comprise one or more false CBF readings for one or more target TBs.The current CU is decoded on the decoder side according to the LFNST mode as indicated by the LFNST syntax. In the encoding process, input data related to a current encoding unit (CU) in a current image is received, where the input data corresponds to primary transformed data. The LFNST process is applied based on an LFNST kernel to derive temporary output data. An LFNST syntax is determined and signaled if one or more conditions are met. These conditions comprise one or more indications from the Encoded Block Indicator (CBF) for one or more target transform blocks (TB) that are false. The current CU is encoded according to the LFNST mode as indicated by the determined LFNST syntax. In one modality, the target TBs correspond to one or more TBs with Transform Jump (TS) indicators not equal to 0. In one mode, in a luminance split tree, the current CU corresponds to a luminance encoding block, and the target TB(s) correspond to one or more luminance TB(s). In another mode, in a chrominance split tree, the current CU corresponds to one or more chrominance encoding blocks, and the target TB(s) correspond to one or more chrominance TB(s). In yet another mode, in a single split tree, the current CU corresponds to a luminance encoding block and one or more chrominance encoding blocks, and the target TB(s) correspond to one or more luminance TB(s) and one or more chrominance TB(s). In one mode, the target TBs correspond to a predefined TB for each encoding block in the current CU. For example, the predefined TB corresponds to the first TB for each encoding block in the current CU. In one mode, if all CBF indications for the target TBs are false, LFNST mode is permitted for the current CU. In another mode, if all CBF indications for the target TBs with Transformer Step (TS) indicators not equal to 0 are false, LFNST mode is permitted for the current CU. In yet another mode, if any CBF indication for the target TBs with Transformer Step (TS) indicators not equal to 0 is true, LFNST mode is disapproved for the current CU. Ln / zznz / E / YiAi BRIEF DESCRIPTION OF THE FIGURES Several forms of this disclosure, which are proposed as examples, will be described in detail with reference to the following figures, where similar numbers refer to similar elements, and where: FIGURE 1 illustrates an example of an LFNST (low frequency non-separable transform) process. FIGURES 2A and 2B show examples of intra sub-partitions (ISP). FIGURE 3 illustrates a flowchart of an exemplary decoding system incorporating LFNST analysis according to an embodiment of the present invention. FIGURE 4 illustrates a flowchart of an exemplary coding system incorporating LFNST analysis according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION It will readily be understood that the components of the present invention, as generally described and illustrated in the figures, can be arranged and designed in a wide variety of different configurations. Therefore, the following more detailed description of the embodiments of the systems and methods of the present invention, as represented in the figures, is not intended to limit the scope of the invention as claimed, but is merely representative of selected embodiments of the invention. References in this specification to “an embodiment,” “the embodiment,” or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the present invention.Therefore, the occurrences of the phrases “in a modality” or “in the modality” in various places throughout this specification do not necessarily refer to the same modality. Furthermore, the described features, structures, or characteristics may be combined in any convenient manner in one or more embodiments. However, a person skilled in the art will recognize that the invention can be practiced without one or more of the specified details, or with other methods, components, etc. In other cases, well-known structures or operations are not shown or described in detail to avoid obscuring aspects of the invention. The illustrated embodiments of the invention will be best understood by reference to the drawings, where similar parts are designated by similar numbers in the document. The following description is intended to be by way of example only and merely illustrates some selected embodiments of apparatus and methods that are consistent with the invention as claimed herein. Combinations of LFNST with transform hopping should not be allowed because when the transform hopping is applied, no transforming process Ln / zznz / E / YiAi (primary transform / kernel and / or secondary transform) should be used. In VVC proposal 7 (B. Bross, et al., “Versatile Video Coding (Draft 7)”, ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29 / WG 11 Joint Video Expert Team (JVET), 16th Meeting: Geneva, CH, 1-11 October 2019, Document: JVET-P2001), the syntax for transform hopping mode is signaled / parsed at the TB level. Furthermore, the syntax for LFNST is signaled / parsed at the CU level after all TU / TBs within those CU / CBs have been signaled / parsed. Therefore, in the current proposed VVC text (as shown in Table 10A), the signaling / analysis conditions for LFNST take into consideration the transform jump indicator for luminance as follows.As shown in the syntax table below, the existing conditions include checking for the luminance transform skip (i.e., transform_skip_flag[xO][yO][0] == 0) to prevent such a combination. For this check, the VVC Test Model version 7 (VTM7, J. Chen, et al., “Algorithm description for Versatile Video Coding and Test Model 7 (VTM 7), ITU-T SG 16 WP 3 Joint Video Expert Team (JVET) and ISO / IEC JTC 1 / SC 29 / WG 11, 16th Meeting: Geneva, CH, 1-11 October, 2019, Document: JVET-P2002) codes appear to match VVC Proposal 7. The syntax table for residual coding according to JVET-P2001 is shown in Table 10B. Table 10A. Signaling / condition analysis for LFNST in Proposal VVC 7 coding_unit( xO, yO, cbWidth, cbHeight, cqtDepth, treeType, modeType ) { Descriptor chType = treeType = = DUAL_TREE_CHROMA ? 1 : 0 s¡( CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA || CuPredMode[ chType ][ xO ][ yO ] = = MODE_PLT ) { si( treeType = = SINGLE TREE | | treeType = = DUAL TREE LUMA ) { s¡( pred_mode_plt_flag ) { palette_coding( xO, yO, cbWidth, cbHeight, treeType )} además { si( sps_bdpcm_enabled_flag && cbWidth <= MaxTsSize && cbHeight <= MaxTsSize) intra_bdpcm_luma_flag ae(v) s¡( intrabdpcmlumaflag) intrabdpcmlumadirflag ae(v) además {}}} si((treeType == SINGLE_TREE | | treeType = = DUAL_TREE_CHROMA ) && ChromaArrayType != 0 ) { s¡( pred_mode_plt_flag && treeType = = DUAL_TREE_CHROMA ) palette_coding( xO, yO, cbWidth / SubWidthC, cbHeight / SubHeightC, treeType ) además { si( !cu_act_enabled_flag ) { s¡( cbWidth <= MaxTsSize && cbHeight <= MaxTsSize && sps_bdpcm_chroma_enabled_flag) { intra_bdpcm_chroma_flag ae(v) s¡( intra_bdpcm_chroma_flag ) intra_bdpcm_chroma_dir_flag ae(v)} además { s¡( CcImEnabled ) cclm_mode_flag ae(v) s¡( cclm_mode_flag) cclm_mode_idx ae(v) además intra_chroma_pred_mode ae(v)}}}}} además si(treeType != DUAL_TREE_CHROMA ) { / * MODEJNTER o MODEJBC * / } s¡( CuPredMode[ chType ][ xO ][ yO ] != MODEJNTRA && !pred_mode_plt_flag && general_merge_flag[ xO ][ yO ] = = 0 ) cu_cbf ae(v) s¡( cu_cbf) { LfnstDcOnly = 1 LfnstZeroOutSigCoeffFIag = 1 MtsZeroOutSigCoeffFIag = 1 transform_tree( xO, yO, cbWidth, cbHeight, treeType,chType ) IfnstWidth = (treeType = = DUAL_TREE_CHROMA) ? cbWidth / SubWidthC : ((IntraSubPartitionsSplitType = = ISP_VER_SPLIT ) ? cbWidth / NumlntraSubPartitions : cbWidth ), n«cn in / 77Π7 / E / γιΛι IfnstHeight = (treeType = = DUAL_TREE_CHROMA) ? cbHeight / SubHeightC : ((IntraSubPartitionsSplitType = = ISP_HOR_SPLIT) ? cbHeight / NumlntraSubPartitions : cbHeight) s¡( Min( IfnstWidth, IfnstHeight) >= 4 && spslfnstenabledflag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && transform_skip_flag[ xO ][ yO ][ 0 ] = = 0 && (treeType != DUALTREECHROMA || !¡ntra_mip_flag[ xO ][ yO ] Min( IfnstWidth, IfnstHeight) >= 16) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag - - 1 ) lfnst_idx ae(v)} s¡( treeType != DUALTREECHROMA && Ifnstjdx = = 0 && transform_skip_flag[ xO ][ yO ][ 0 ] = = 0 && Max( cbWidth,cbHeight) <= 32 && IntraSubPartitionsSplit[ xO ][ yO ] = = ISP_NO_SPLIT && cu_sbt_flag = = 0 && MtsZeroOutSigCoeffFIag = = 1 && tu_cbf_luma[ xO ][ yO ]) { s¡( (( CuPredMode[ chType ][ xO ][ yO ] == MODEJNTER && sps_expl¡cit_mtsjnter_enabled_flag) | | ( CuPredMode[ chType ][ xO ][ yO ] == MODE_INTRA && sps_expl¡cit_mtsjntra_enabled_flag))) mtsjdx ae(v)}}, Tabla 10B. Tabla de sintaxis para codificación residual en Propuesta VVC 7 residual_coding( xO, yO, log2TbWidth, log2TbHeight, cldx ) { Descriptor s¡( sps_mts_enabled_flag && cu_sbt_flag && cldx = = 0 && log2TbWidth = = 5 && log2TbHeight < 6 ) log2ZoTbWidth = 4 además log2ZoTbWidth = Min( log2TbWidth, 5 ) s¡( sps mts enabled flag && cu sbt flag && cldx = = 0 && log2TbWidth < 6 && log2TbHeight = = 5 ) log2ZoTbHeight = 4 además log2ZoTbHeight = Min( log2TbHeight, 5 ) s¡( log2TbWidth > 0) last_sig_coeff_x_prefix ae(v) s¡( log2TbHeight > 0 ) last_sig_coeff_y_prefix ae(v) s¡( last_sig_coeff_x_prefix > 3) last_sig_coeff_x_suffix ae(v) s¡( last_sig_coeff_y_prefix > 3 ) last_sig_coeff_y_suffix ae(v) log2TbWidth = log2ZoTbWidth log2TbHeight = log2ZoTbHeight remBinsPassl = ((1 «(log2TbWidth + log2TbHeight) )‘7)»2 log2SbW = ( Min( log2TbWidth,log2TbHeight) < 2 ? 1 : 2) log2SbH = log2SbW s¡( log2TbWidth + log2TbHeight > 3 ) { s¡( log2TbWidth < 2 ) { log2SbW = log2TbWidth log2SbH = 4 - log2SbW} además si( log2TbHeight < 2 ) { log2SbH = log2TbHeight log2SbW = 4 - log2SbH}} numSbCoeff = 1 «(log2SbW + log2SbH ) lastScanPos = numSbCoeff lastSubBlock = ( 1 « (log2TbWidth + log2TbHeight - (log2SbW + log2SbH )))-1 hacer{ si( lastScanPos = = 0 ) { lastScanPos = numSbCoeff lastSubBlock- -} lastScanPos— xS = DiagScanOrder[ log2TbWidth - log2SbW ][ log2TbHeight - log2SbH ] [ lastSubBlock ][ 0 ] yS = DiagScanOrder[ log2TbWidth - log2SbW ][ log2TbHeight - log2SbH ] [ lastSubBlock ][ 1 ] xC = ( xS « log2SbW ) + DiagScanOrder[ log2SbW ][ log2SbH ][ lastScanPos ][ 0 ] yC = ( yS « log2SbH ) + DiagScanOrder[ log2SbW ][ log2SbH ][ lastScanPos ][ 1 ]} mientras( ( xC != LastSignificantCoeffX ) | | ( yC != LastSignificantCoeffY)), n«cn ίη / ζζηζ / Ε / γίΛΐ s¡( lastSubBlock = = 0 && log2TbWidth >= 2 && log2TbHeight >= 2 && !transform_skip_flag[ xO ][ yO ][ cldx ] && lastScanPos > 0 ) LfnstDcOnly = 0 s¡( (lastSubBlock > 0 && log2TbWidth >= 2 && log2TbHeight >= 2 ) | | ( lastScanPos > 7 && ( log2TbWidth = = 2 | | log2TbWidth = = 3 ) && log2TbWidth = = log2TbHeight)) LfnstZeroOutSigCoeffFIag = 0 s¡( ( LastSignificantCoeffX > 15 | | LastSignificantCoeffY > 15 ) && cldx = = 0) MtsZeroOutSigCoeffFIag = 0}}} In the existing LFNST signaling / analysis condition, two problems are observed. One problem is that when luminance and chrominance use different split trees, it fails to find the transform skip flag for luminance (i.e., transform_skip_flag[x0][y0][0]) when the current CU is in a chrominance split tree (i.e., the case with treeType == DUALTREECHROMA). The other problem is caused by the extension of the transform skip to chrominance as disclosed in JVET-P0058. The aforementioned check should be extended to include Cb and Cr checks. Several methods are proposed to address these problems. The proposed check involves considering the transform jump indicator condition of M TB(s) in the CU. For a TB with one or more transform coefficient levels not equal to 0, the transform jump indicator for the TB is used to indicate whether transform operations are applied to the TB, and the proposed check is used to avoid TBs from LFNST combinations with transform jumps. As mentioned previously, in a corresponding split tree, which can be a luminance split tree (DUAL_TREE_LUMA), a chrominance split tree (DUALTREECHROMA), or a single split tree (SINGLETREE), there are one or more TBs in the current CU. The M TB(s) correspond to a set of selected TBs, referred to as the target TBs. The transform jump indicator condition of the target TB set is checked.Passing the check means that the transform jump indicator for all M TBs is false (i.e., the transform jump indicator for all M TBs is equal to 0); in other words, passing the check means that the objective condition is satisfied (which corresponds to the one where all objective TBs in the set are true). The target TBs (Ln / zznz / E / YiAi) have a TS mode indicator as false. In other words, the transform hop mode indicator condition is satisfied if none of the selected TBs use transform hop mode. After passing the check (i.e., the transform hop mode indicator condition is satisfied), the signaling / parsing conditions for LFNST related to transform hop mode are satisfied, and the syntax for LFNST can be signaled / parsed if other signaling / parsing conditions for LFNST are also satisfied. In one mode, M TB(s) only include the first component in each luminance / chrominance split tree. An example of the proposed syntax table is shown below. Table 11. An exemplary syntax table for signaling / condition analysis for LFNST according to an embodiment of the present invention. S¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && transform_skip_flag[ xO ][ yO ][ chType ] = = 0 && (treeType != DUAL_TREE_CHROMA || !¡ntra_mip_flag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >= 16) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( ( IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} In another modality, for a single split tree used for both luminance and chrominance components, M TB(s) include one or more components. In a sub-modality, M TB(s) refers to a selected component. For example, M TB(s) refers to the first component. In another example, M TB(s) refers to Y (i.e., the luminance component). An exemplary syntax table is shown below, according to a modality. In another example, M TB(s) can be any component in the split tree. Ln / zznz / E / YiAi Table 12. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && (treeType = = SINGLE TREE && transformskipJlag[ xO ][ yO ][ 0 ] = = 0) && (treeType != DUAL_TREE_CHROMA || !¡ntra_mipjlag[ xO ][ yO ] Min( IfnstWidth, IfnstHeight) >= 16 ) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} In another modality, when the split tree is not a chrominance tree (i.e., the split tree contains the Y component (i.e., luminance)), M TB(s) refers to Y TB(s) (i.e., luminance). An example syntax table according to one modality is shown below. Table 13. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. if( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && (treeType != DUAL TREE CHROMA && transform_skipjlag[ xO ][ yO ][ 0 ] = = 0) && (treeType != DUAL TREE CHROMA | LfnstZeroOutSigCoeffFIag = = 1 ) Ifnstjdx ae(v)} In another form, for a chrominance split tree, M TB(s) includes all chrominance components (e.g., Cb and Cr). If any transform jump indicator for the chrominance components is false (i.e., transform jump indicator equal to 0), the check passes. In another mode, for a luminance split tree, M TB(s) includes all components (e.g., Y). If any transform jump indicator for these components is false (i.e., transform jump indicator equal to 0), the check passes. Table 14 shows an example syntax table according to this mode. In another mode, for a single tree used for luminance and chrominance components, M TB(s) includes all components (e.g., Y, Cb, and Cr). If any transform jump indicator for these components is false (i.e., transform jump indicator equal to 0), the check passes. Table 14 shows an example syntax table according to this mode. Table 14. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. s¡( Min( IfnstWidth, IfnstHeight) >= 4 && spslfnstenabledflag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && (treeType == DUALTREECHROMA? (transform_skip_flag[ xO ][ yO ][ 1] = = 0 | transform_skip_flag[ xO ][ yO ][ 2 ] = = 0) : (treeType == DUAL TREE LUMA ? transform_skip_flag[ xO ][ yO ][ 0] = = 0: (transform_skip_flag[ xO ][ yO ][ 01 = = 0 II transform_skip_flag[ xO ][ yO ][ 1] = = 0 || transform_skip_flag[ xO ][ yO ][ 2] = = 0))) && (treeType != DUAL_TREE_CHROMA || !intra_mip_flag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >= 16) && Max( cbWidth, cbHeight) <= MaxTbSizeY){ si( ( IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} In another form, for a chrominance split tree, M TB(s) includes all chrominance components (e.g., Cb and Cr). If all transform jump indicators for the chrominance components are false (i.e., all transform jump indicators for the chrominance components are equal to 0), the check passes. In another mode, for a luminance split tree, M TB(s) includes all luminance components (e.g., Y). If all transform jump indicators for these components are false (i.e., all transform jump indicators for these components are equal to 0), the check passes. Table 15 shows an example syntax table according to this mode. In another mode, for a single tree used for luminance and chrominance components, M TB(s) includes all components (e.g., Y, Cb, and Cr). If all transform jump flags for these components are false (i.e., transform jump flag equal to 0), the check passes. Table 15 shows an example syntax table according to this mode. In yet another mode, two or more of the three previous modes can be combined. For example, the combined mode can only check the luminance transform_skip_flag when the split tree is not a chrominance split tree (e.g., not for DUALTREECHROMA) and only checks the chrominance transform_skip_flag when the split tree is not a luminance split tree (e.g., not for DUAL_TREE_LUMA). Table 15 shows an example syntax table according to this mode. nAcn Ln / zznz / E / YiAi Table 15. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODE_INTRA && (treeType == DUAL_TREE_CHROMA? (transform_skip_flag[ xO ][ yO ][ 1] = = 0 && transform_skip_flag[ xO ][ yO ][ 2 ] = = 0) : (treeType == DUAL_TREE_LUMA ? transform_skip_flag[ xO ][ yO ][ 0] = = 0: (transform_skip_flag[ xO ][ yO ][ 0] == 0 && transform_skip_flag[ xO ][ yO ][ 1] = = 0 && transform_skip_flag[ xO ][ yO ][ 2] = = 0))) && (treeType != DUALTREECHROMA || !¡ntra_mip_flag[ xO ][ yO ] | Min( IfnstWidth, IfnstHeight) >= 16) && Max( cbWidth, cbHeight) <= MaxTbSizeY){ s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} Table 16 shows another example syntax table for the combination of the three above modalities. Ln / zznz / E / YiAi Table 16. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. if( Min( IfnstWidth, IfnstHeight) >= 4 && spsjfnst_enabled_flag == 1 &&CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && (treeType == DUAL TREE CHROMA | | transform_skip_flag[ xO ][ yO ][ 0 ] = = 0) && (treeType == DUALTREELUMA (transform skip flagj xO ][ yO ][ 1 ] = = 0 && transform_skip_flag[ xO ][ yO ][ 2 ] == 0)) && (treeType DUAL TREE CHROMA | | !¡ntra_mip_flag[ xO ][ yO ] | |Min( IfnstWidth, IfnstHeight) >= 16 ) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && LfnstZeroOutSigCoeffFIag = = 1 ) Ifnstjdx ae(v)} In another mode, the check is not passed; the syntax for LFNST (e.g., LFNST index) is not flagged / parsed. In one sub-modality, the syntax for LFNST (LFNST index) is inferred as 0 (i.e., LFNST is not applied). In another mode, bitstream conformance is required to handle the case if the check fails. Bitstream conformance is as follows. It is a bitstream conformance requirement that the value of lfnst_index should not be greater than 0 when the check fails. Hereafter, an example of bitstream conformance is illustrated for the check case “the transform jump indicator(s) for M TB(s)”, where M TB(s) means only the first component in each luminance / chrominance split tree.The bitstream shaping requirement corresponds to that where the value of Ifnstjndice should not be greater than 0 when the transform skip flag value for the first component in each luminance / chrominance split tree (e.g., transform_skip_flag[xO][yO][chType], where if treeType == DUALTREECHROMA, chType indicates 1 (i.e., Cb); otherwise, chType indicates 0 (i.e., Y)) is greater than 1. In another embodiment, a variable can be created in the proposal text or software to record whether the syntax for LFNST is signaled / analyzed. The value of this variable is updated according to one or more existing signaling / analysis conditions for LFNST and / or one or more checks proposed in this invention. For example, this variable is initialized to 1, and if any existing signaling / analysis condition is not met for Ln / zznz / E / YiAi LFNST and / or one or more checks proposed in this invention, this variable is changed to 0 and the syntax for LFNST is not signaled / analyzed. In another mode, a unification check mechanism is used for different split trees for luminance and chrominance. For example, when luminance and chrominance use dual trees (i.e., separate split trees), the luminance CU is on a luminance split tree and the chrominance CU is on a chrominance split tree. The unification mechanism is that LFNST is disabled if any of the transform hop indicators for all components in the current CU are using transform hopping. Due to the current size restriction for LFNST, LFNST can be applied when a CU / CB contains a TU / TB. The check can take into account the transform jump indicator for a single TU / TB instead of multiple TU / TBs. When a CU / CB contains multiple TU / TBs, the proposed check is based on one or more TU / TBs in that CU / CB. In one mode, the proposed check is based on all TU / TBs in that CU / CB. In another mode, the check is based on any one of the TU / TBs in that CU / CB (e.g., the first or last TU / TB). For example, in a luminance split tree, the target TB set comprises the first luminance TB for the luminance CB in the current CU. For another example, in a chrominance split tree, the target TB set comprises the first Cb TB for the Cb CB in the current CU and the first Cr TB for the Cr CB in the current CU.For another example, in a single split tree, the target TB set comprises the first luminance TB for the luminance CB in the current CU, the first Cb TB for the Cb CB in the current CU, and the first Cr TB for the Cr CB in the current CU. In another modality, the check is against any subset of the TU / TB in that CU / CB. Furthermore, the use of LFNST may be limited under certain conditions. In the current design, LFNST is applied for intra- and inter-segment CU measurements, as well as for luminance and / or chrominance. If a dual tree is enabled, LFNST indices for luminance and chrominance are signaled / analyzed separately. For inter-segment measurements, where the dual tree is disabled, a single LFNST index is signaled / analyzed and used for either luminance and / or chrominance. In this invention, the chrominance LFNST is disabled in some cases. In one mode, for a single tree, chrominance LFNST is disabled. In one sub-mode, when chrominance LFNST is disabled, the LFNST index is still signaled / analyzed and can be used for luminance. In another mode, LFNST chrominance is disabled. In a sub-modality, when chrominance LFNST is disabled, the index Ln / zznz / E / YiAi LFNST is not signaled / analyzed in the dual chrominance tree. In another scenario, LFNST cannot be used for a TB even if the LFNST index for the CU containing the TB is greater than zero. A variable, appIyLfnstFIag, is created to indicate whether LFNST can be used. If appIyLfnstFIag equals 0, LFNST cannot be used. If appIyLfnstFIag equals 1, LFNST can be used. For example, for a single tree, chrominance LFNST is disabled. The variable appIyLfnstFIag is derived as follows: (where xTbY and yTbY signify the corresponding luminance sample location for the TB, cldx refers to the component for the TB (e.g., cldx equal to 0 referring to the luminance component, cldx equal to 1 referring to the Cb component, and cldx equal to 2 referring to the Cr component), Ifnstjdx is the LFNST index for the CU, and nTbW and nTbH signify the width and height of the TB) - If (1) treeType is equal to SINGLETREE, (2) Ifnstjdx is not equal to 0, (3) transform skip flag[ xTbY ][ yTbY ][ cldx ] is equal to 0, (4) cldx is equal to 0 and (5) both nTbW and nTbH are greater than or equal to 4, appIyLfnstFIag is set to 1. (Any subset of (1) to (5) may be used in this condition.) - Otherwise, if (1) treeType is not equal to SINGLE TREE, (2) Ifnstjdx is not equal to 0, (3) transform_skipjlag[ xTbY ][ yTbY ][ cldx ] is equal to 0 and (4) both nTbW and nTbH are greater than or equal to 4, appIyLfnstFIag is set to 1. (Any subset of (1) to (4) can be used in this condition) - Otherwise, appIyLfnstFIag is set to 0. For another example, chrominance LFNST is disabled. The appIyLfnstFIag variable is derived as follows: - If (1) Ifnstjdx is not equal to 0, (2) transform_skipjlag[ xTbY ][ yTbY ][ cldx ] is equal to 0, (3) cldx is equal to 0 and (4) both nTbW and nTbH are greater than or equal to 4, appIyLfnstFIag is set to 1. (Any subset from 1 to 4 can be used in this condition) - Otherwise, appIyLfnstFIag is set to 0. In another sub-modality, appIyLfnstFIag can be used in one or more sections related to LFNST. For example, the LFNST index is referenced in a corresponding section in the proposed standard. 8.7.4 Transformation process for scaled transform coefficients ....When appIyLfnstFIag is equal to 1 / / Ifnstjdx is not equal to 0 and transform skipJlag[ xTbY ][ yTbY ][ cldx ] is equal to 0 and both nTbW and nTbH are greater than or equal to 4 / / , the following applies:... In the texts modified above based on the proposed standard, the texts surrounded by a pair of “ / / ” indicate deleted texts. Ln / zznz / E / YiAi 8.7.3 Scaling process for transform coefficients ...For the derivation of the scaled transform coefficients d[x ][y] with x = O..nTbW - 1, y = O..nTbH - 1, apply the following: - The intermediate scaling factor m[ x ][ y ] is derived as follows: - If one or more of the following conditions are true, m[ x ][ y ] is set equal to 16: - sps_scaling_list_enabled_flag is equal to 0. - pic_scaling_list_present_flag is equal to 0. - transform_skip_flag[ xTbY ][ yTbY ][ cldx ] is equal to 1. - scaling_matrix_for_lfnst_disabled_flag is equal to 1 and appIyLfnstFIag is equal to 1 / / lfnst_idx[ xTbY ][ yTbY ] is not equal to 0 / / .... In the above modified texts based on the proposed standard, texts surrounded by a pair of 7 / ” indicate deleted texts. In another scenario, when chrominance LFNST is disabled in some cases, LfnstDcOnly, which is initialized to 1 before analyzing each TB in a CU and is changed to 0 if any TB in that CU has any significant coefficients (or the last significant coefficient) located at a position larger than the DC position, is not updated in non-LFNST TBs. For example, chrominance LFNST is disabled for a single tree. Consequently, non-LFNST TBs include the chrominance TBs for that single tree. An example of the corresponding changes in the syntax table is shown below. Table 17. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. Residual_coding( xO, yO, log2TbWidth, log2TbHeight, cldx ) {... Descriptor s¡( lastSubBlock = = 0 && log2TbWidth >= 2 && log2TbHeight >= 2 && !transform_skip_flag[ xO ][ yO ][ cldx ] && lastScanPos > 0 && ((cldx == 0) II (treeType != SINGLE_TREE))) LfnstDcOnly = 0 s¡( (lastSubBlock > 0 && log2TbWidth >= 2 && log2TbHeight >= 2 ) | | (lastScanPos > 7 && (log2TbWidth = = 2 | | log2TbWidth = = 3 ) && log2TbWidth = = log2TbHeight)) LfnstZeroOutSigCoeffFIag = 0} Ln / zznz / E / YiAi In another example, chrominance LFNSTs are disabled, and non-LFNST TBs include chrominance TBs. An example of the corresponding changes in the syntax table is shown below. Table 18. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. residual_coding( xO, yO, log2TbWidth, log2TbHeight, cldx ) {... Descriptor s¡( lastSubBlock = = 0 && log2TbWidth >= 2 && log2TbHeight >= 2 && !transform_skip_flag[ xO ][ yO ][ cldx ] && lastScanPos > 0 && ( cldx = 0)) LfnstDcOnly = 0 s¡( (lastSubBlock > 0 && log2TbWidth >= 2 && log2TbHeight >= 2 ) | | (lastScanPos > 7 && (log2TbWidth = = 2 11 log2TbWidth = = 3 ) && log2TbWidth = = log2TbHeight)) LfnstZeroOutSigCoeffFIag = 0 ·} When a luminance tree (TB) does not have cbf, a transform process does not need to be applied. However, the LFNST index can still be signaled / analyzed in this case. For example, for a single tree, when the luminance does not contain cbf, but the chrominance meets the LFNST signaling / analysis condition (e.g., the chrominance is not a transform step and has coefficients located in a non-DC position), the LFNST index can be signaled / analyzed. In this case, the LFNST index is signaled / analyzed and always has a value of 0, because LFNST is applied to luminance for a single tree and the index is redundant. In one mode, LfnstDcOnlyFlag is updated by Y only (the TB LFNST-aser-applied) for a single tree. In another mode, LfnstDcOnlyFlag is separated into LfnstDCOnlychromaFlag and IfnstDCOnlychromaFlag. LfnstDCOnlychromaFlag is updated by Y TB and IfnstDCOnlychromaFlag is updated by the TBs of Cb or Cr. In a sub-modality, for a single tree, only LfnstDConlychromaFlag is considered for LFNST signaling / analysis. In another sub-modality, for dual luminance tree, only LfnstDConlychromaFlag is considered for LFNST signaling / analysis. ίη / ζζηζ / Ε / γίΛΐ In another sub-modality, for dual chrominance tree, only LfnstDConlychromaFlag is considered for LFNST signaling / analysis. In another mode, a check for LFNST signaling is added as follows: If luminance has no Cbf, the LFNST index is not signaled / analyzed. An example of the syntax table is shown below. Table 19. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. IfnstNotTsFlag = (treeType = = DUAL_TREE_CHROMA | | transform_skipjlag[ xO ][ yO ][ 0 ] = = 0) && (treeType = = DUAL TREE LUMA | | (transform_skip_flag[ xO ][ yO ][ 1 ] = = 0 && _________transform _skip flagf xO ][ yO ][ 2 ] == 0 ))_____________________________________________ s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && IfnstNotTsFlag = = 1 && (treeType == DUAL_TREE_CHROMA || !¡ntra_mip_flag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >=16) &&Max(cbWidth,cbHeight) <= MaxTbSizeY) s¡( ( IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && _______________LfnstZeroOutSigCoeffFIag = = 1 )_________________________________________ si (treeType = = DUALTREECHROMA || tu_cbf_luma[xO][yO]) ________lfnst_idx____________________________________________________________________________ ____________________________1______________________________________________________________________________________________________________________________________ In a sub-modality, this check is added to the check at the CU level. In another sub-modality, this check is added to the TB-level check. In another sub-mode, this check is performed for a single tree as shown in the following example. Table 20. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. IfnstNotTsFlag = (treeType == DUALTREECHROMA || transform_skip flag[ xO ][ yO ][ 0 ] = = 0) && (treeType = = DUALTREELUMA | | (transform skip flag[ xO ][ yO ][ 1 ] = = 0 && _________transform_skip_flag[ xO ][ yO ][ 2 ] = = 0 ))____________________________________________ s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && IfnstNotTsFlag = = 1 && (treeType == DUAL_TREE_CHROMA || !¡ntra_mipjlag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >=16) &&Max(cbWidth,cbHeight) <= MaxTbSizeY) { && s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstZeroOutSigCoeffFIag = = 1 ) LfnstDcOnly = = 0 ) if (treeType ! = SINGLE TREE || tu. cbf..luma[xO][yO]) Ifnstjdx} n«cn Ln / zznz / E / YiAi In another sub-mode, this check is not limited to ISP mode. The reason is described below. When ISP is applied, a luminance CB is partitioned into multiple TBs (e.g., 4 TBs), and at least one significant coefficient is contained within a TB (the TBs containing significant coefficients can be any one or more TBs within this CU). Examples from the syntax table are shown below. Table 21 A. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. IfnstNotTsFlag = (treeType = = DUAL_TREE_CHROMA | | transform_skip_flag[ xO ][ yO ][ 0 ] = = 0) && (treeType == DUAL_TREE_LUMA || (transform_skipjlag[ xO ][ yO ][ 1 ] = = 0 && ________transformskipflagf xO ][ yO ][ 2 ] = = 0 ))__________________________________________ if( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && IfnstNotTsFlag = = 1 && (treeType = = DUALTREECHROMA | | !¡ntra_mipjlag[ xO ][ yO ] | | Min( IfnstWidth, IfnstHeight) >= 16) && Max(cbWidth,cbHeight) <= MaxTbSizeY) s¡( ( IntraSubPartitionsSplltType != ISP_NO_SPLIT | | LfnstDcOnly = = 0 ) && _______LfnstZeroOutSigCoeffFIag = = 1 )________________________________________ if (treeType ! = SINGLE_TREE || (tu_cbfJuma[xO][yO] || IntraSubPartitionsSplitType ISPNOSPLIT)) Ifnstjdx__________________________________ _____________1__________________________________________________________________________________________________________________________________________ Table 21B. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. IfnstNotTsFlag = (treeType = = DUALTREECHROMA | | transform_skipJlag[ xO ][ yO ][ 0 ] = = 0) && (treeType = = DUAL TREE LUMA | | (transform skipJlag[ xO ][ yO ][ 1 ] = = 0 && _________transform_skipjlag[ xO ][ yO ][ 2 ] = = 0 ))____________________________________________ if( Min( IfnstWidth, IfnstHeight) >= 4 && spsjfnst_enabledjlag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEJNTRA && IfnstNotTsFlag = = 1 && (treeType = = DUAL_TREE_CHROMA | | !¡ntra_mipjlag[ xO ][ yO ] | | Min( IfnstWidth, IfnstHeight) >= 16) && Max(cbWidth,cbHeight) <= MaxTbSizeY) J____________________________________________________________________ s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | (LfnstDcOnly = = 0 && (treeType != SINGLE_TREE || tu_cbf_luma[xO][yO] )) && _______________LfnstZeroOutSigCoeffFIag = = 1 )_______________________________________________ ______________IfnsIJdx___________________________________________________________ _________________________1__________________________________________________________________________________________________________________________ Table 21C. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. IfnstNotTsFlag = (treeType = = DUAL_TREE_CHROMA | | transform_skip_flag[ xO ][ yO ][ 0 ] = = 0) && (treeType == DUAL_TREE_LUMA || (transform_skip_flag[ xO ][ yO ][ 1 ] == 0 && _________transform skip flagf xO ][ yO ][ 2 ] = = 0 ))_______________________________________________ s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] == MODEINTRA && IfnstNotTsFlag = = 1 && (treeType = = DUAL_TREE_CHROMA | | !¡ntra_mipjlag[ xO ][ yO ] | | Min( IfnstWidth, IfnstHeight) >= 16) && Max(cbWidth,cbHeight) <= MaxTbSizeY) J________________________________________________________ s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | (LfnstDcOnly = = 0 && ( !( treeType == SINGLE TREE && tu_cbfJuma[xO][yO])) ) && _______________LfnstZeroOutSigCoeffFIag = = 1 )_________________________________________ ______________IfnsIJdx___________________________________________________________ ____________________________1_____________________________________________________________________________________________________________________________________ In Tables 20 and 21A to 21C above, IfnstNotTsFlag is an indicator, where if IfnstNotTsFlag equals 1, the LFNST mode can be applied (assuming other LFNST enable conditions are satisfied). Otherwise (i.e., IfnstNotTsFlag equals 0), the LFNST mode cannot be applied (i.e., LFNST syntax is inferred as disabled). In another sub-mode, this check is performed for dual luminance tree. In one mode, when the Ifnst index > 0 (i.e., Ifnst is executed), LFNST is applied to the first available component in a split tree. LFNST is not applied to the remaining components. In a submodality, the first available component is the first component containing cbf. For example, for dual-tree chrominance, if cb contains significant coefficients, the first available component is Cb; otherwise, if Cb cbf = 0 and Cr contains significant coefficients, the first available component is Cr; otherwise, if Cb and Cr do not contain a significant coefficient, Ifnst is not applied (i.e., the Ifnst index is inferred as 0 with no signaling). For another example, Ifnst is applied to luminance for a single tree. In this case, if luminance contains significant coefficients, the first available component is Ln / zznz / E / YiAi luminance; otherwise, Ifnst is not applied. In another mode, when the JCCR mode is activated, a single residual joint chrominance block (resJointC[x][y] in Table 7) is signaled / analyzed, so that Ifnst can be applied to that single block (i.e., LFNST affecting both Cb and Cr). In another modality, Ifnst is signaled / analyzed in the first available TB. In a sub-modality, the first available TB is the first TB that contains cbf. For example, for dual-tree chrominance, if cb contains significant coefficients, the first available TB is Cb; otherwise, if Cb cbf = 0 and Cr contains significant coefficients, the first available TB is Cr; otherwise, if Cb and Cr do not contain a significant coefficient, Ifnst is not applied (i.e., the Ifnst index is inferred as 0 without signaling). For another example, Ifnst is applied to luminance. For single-tree chrominance, if luminance contains significant coefficients, the first available component is luminance; otherwise, Ifnst is not signaled / analyzed. In another sub-modality, when joint chrominance residual coding (JCCR) is applied to dual-tree chrominance, the first available TB is the chrominance TB whose residuals are used to derive the residuals for the other chrominance component. LFNST can be seen as being applied to both chrominance components. For example, for dual-tree chrominance, if tu_cbf_cb[xO][yO] > 0 and tu_cbf_cr[xO][yO] = 0 (the Cr residuals being derived from Cb and the information associated with the Cb residual being signaled), the first available TB is Cb. For another example, for dual-tree chrominance, if tu_cbf_cb[xO][yO] = 0 and tu_cbf_cr[xO][yO] > 0 (the Cb residuals are derived from Cr and the information associated with the Cr residual being signaled), the first available TB is Cr.For another example, for dual-tree chrominance, if tu_cbf_cb[xO][yO] > 0 and tu_cbf_cr[xO][yO] > 0 (the Cr residuals being derived from Cb and the information associated with the Cb residual being signaled), the first available TB is Cb. In another sub-modality, the Ifnst index is signaled / analyzed at the end of the first available TB. For example, the Ifnst index is analyzed after analyzing the residuals for each subblock (coding group or 4x4 subblock) in that TB. In another sub-modality, the Ifnst index is signaled / analyzed after signaling / analyzing the significant indicator of that TB. The signaling / analysis conditions for LFNST (e.g., LfnstDcOnlyFlag or LfnstZeroOutSigCoeffFIag) depend on the information from the first available TB only. In another mode, for a single tree, Ifnst is applied to luminance only. When luminance cannot be used for Ifnst (e.g., the luminance does not contain cbf), the Ifnst index is not signaled / analyzed even when chrominance is available for Ifnst signaling / analysis (e.g., chrominance containing cbf or JCCR being used for chrominance). When a TB block lacks a cbf, no transform process is required. However, the transform jump (TS) indicator can still be 1 in this case. For example, for a BDPCM block, the transform jump indicator is inferred to be 1. However, this BDPCM block may not contain a cbf. When considering LFNST signaling / analysis, the TB block without a cbf is treated as a TS block, and the LFNST index cannot be signaled / analyzed because LFNST is not permitted for a TS block. Several methods are proposed to avoid these unexpected cases. In one mode, when considering LFNST signaling / analysis, the Coded Block Flag (CBF) indication is used to prevent LFNST disqualification for a CU containing one or more TBs that have one or more TS flags not equal to 0 but are not actually executed with TS process. First, a Coded Block Flag (CBF) indication for the current CU is checked. The CBF indication for the current CU is denoted as cu_coded_flag (or cu_cbf). `cu_coded_flag` equal to 1 specifies that the syntax structure `transform_tree()` is present for the current encoding unit. `cu_coded_flag` equal to 0 specifies that the syntax structure `transform_tree()` is not present for the current encoding unit. When cu_coded_flag is not present, it is inferred as follows: If cu_skip_flag[ xO ][ yO ] is equal to 1 or pred_modo_plt_flag is equal to 1, cu_coded_flag is inferred to be equal to 0. Otherwise, cu_coded_flag is inferred to be equal to 1. If the CBF indication for the current CU is true, the following checks that one or more indications are required for one or more target TBs; otherwise, the LFNST syntax is inferred as disabled. In one mode, when considering signaling / analyzing an LFNST index, in addition to checking the CBF indicator for the current CU, tu_cbf is also checked. Therefore, for a TB with a TS indicator of 1, if this TB does not contain a cbf, then it will not be seen as a TS block for LFNST signaling / analysis. The IfnstNotTsFlag is updated as follows: IfnstNotTsFlag = (treeType = = DUALTREECHROMA | | (transform_skip_flag[ xO ][ yO ][ 0 ] = = 0 || !tu_cbf_luma[xO][yO]) ) && (treeType = = DUALTREELUMA | | ((transform_skip_flag[ xO ][ yO ][ 1 ] = = 0 11 !tu_cbf_cb[xO][yO]) && (transform_skip_flag[ xO ][ yO ][ 2 ] = = 0 || !tu_cbf_cr[xO][yO]))) The derivation of IfnstNotTsFlag as shown above is based on at least one of the Ln / zznz / E / YiAi Ln / zznz / E / YiAi two factors: the TS mode indication is false and the CBF indication is false. LFNST mode is permitted for the current CU if each target TB satisfies at least one of factor 1 and factor 2. Permitting LFNST mode for the current CU means that if other LFNST enable conditions are met, the LFNST syntax is signaled / parsed to indicate whether LFNST mode is applied to the current CU and / or which LFNST kernel is applied when LFNST mode is applied. The TS mode indication depends on the transform jump (TS) indicator. The CBF indication depends on the encoded block (cbf) indicator for a target TB. Cbf for Y, Cb, and Cr can be represented by tu_y_coded_flag (or tu_cbf_luma), tu_cb_coded_flag (or tu_cbf_ cb) and tu_cr_coded_flag (or tu_cbf_cr). tu_cb_coded_flag[ xO ][ yO ] equal to 1 specifies that the Cb transform block contains one or more transform coefficient levels not equal to 0. The array indices xO and yO specify the location ( xO, yO ) of the upper-left luminance sample of the considered transform block relative to the upper-left luminance sample of the image. When your_cb_coded_flag[ xO ][ yO ] is not present, its value is inferred to be equal to 0. tu_cr_coded_flag[ xO ][ yO ] equal to 1 specifies that the transform block Cr contains one or more transform coefficient levels not equal to 0. The array indices xO, yO specify the location ( xO, yO ) of the upper-left luminance sample of the considered transform block relative to the upper-left luminance sample of the image. When your_cr_coded_flag[ xO ][ yO ] is not present, its value is inferred to be equal to 0. tu_y_coded_flag[ xO ][ yO ] equal to 1 specifies that the luminance transform block contains one or more transform coefficient levels not equal to 0. The array indices xO, yO specify the location ( xO, yO ) of the upper-left luminance sample of the considered transform block relative to the upper-left luminance sample of the image. When tu_y_coded_flag[ xO ][ yO ] is not present and treeType is not equal to DUALTREECHROMA, its value is inferred as follows: - If cusbtflag is equal to 1 and one of the following conditions is true, tu_y_coded_flag[ xO ][ yO ] is inferred to be equal to 0: - subTu Index is equal to 0 and cu_sbt_pos_flag is equal to 1; - subTu Index is equal to 1 and cu_sbt_pos_flag is equal to 0. - Otherwise, tu_y_coded_flag[ xO ][ yO ] is inferred as equal to 1. Ln / zznz / E / YiAi For example, in a luminance split tree: - If the TS indicator for a target luminance TB is equal to 0, IfnstNotTsFlag is set to 1. - If the target luminance TB does not contain significant coded data (CBF indications equal to false), IfnstNotTsFlag is set to 1. - Other: IfnstNotTsFlag is set to 0. For another example, in a chrominance split tree: - If the TS indicators for all target Cb and Cr TBs are equal to 0, IfnstNotTsFlag is set to 1. - If “all target TBs do not contain significant encoded data”, IfnstNotTsFlag is set to 1. - If “each TS target TB (TS target TB = TS target TB with indicator TS not equal to 0) does not contain significant coded data”, IfnstNotTsFlag is set to 1. - Other: IfnstNotTsFlag is set to 0. For another example, in a single-split tree: - If the TS indicators for all TB luminance, Cb, and Cr target values ​​are equal to 0, IfnstNotTsFlag is set to 1. - If “all target TBs do not contain significant encoded data”, IfnstNotTsFlag is set to 1. - If “each TS target TB (TS target TB = TS target TB with indicator TS not equal to 0) does not contain significant coded data, IfnstNotTsFlag is set to 1. - Otherwise, IfnstNotTsFlag is set to 0. In one mode, the target TBs correspond to one or more TBs with Transform Jump (TS) indicators not equal to 0. In one mode, in a luminance split tree, the current CU corresponds to a luminance coding block, and the target TB corresponds to one or more luminance TBs. In another mode, in a chrominance split tree, the current CU corresponds to one or more chrominance coding blocks, and the target TB corresponds to one or more chrominance TBs. For example, the chrominance coding blocks are Cb and Cr coding blocks, and the chrominance TBs are Cb and Cr TBs. In yet another mode, in a single split tree, the current CU corresponds to a luminance coding block and one or more chrominance coding blocks, and the target TB corresponds to one or more luminance TBs and one or more chrominance TBs. For example, the chrominance coding blocks are Cb and Cr coding blocks, and the chrominance TBs are Cb and Cr TBs. Ln / zznz / E / YiAi In one mode, the target TBs correspond to a predefined TB for each encoding block in the current CU. For example, the predefined TB corresponds to the first TB for each encoding block in the current CU. The location of the first TB can be the location of the upper-left luminance sample of the considered transform block. The location of the first TB can be the location of the upper-left luminance sample of the considered encoding block (the CB considered in the current CU) relative to the upper-left luminance sample of the image. In one mode, if all CBF indications for the target TBs are false, LFNST mode is permitted for the current CU (without considering TS checks). In another mode, if all CBF indications for the target TBs with Transform Step (TS) indicators not equal to 0 are false, LFNST mode is permitted for the current CU. In yet another mode, if any CBF indications for the target TBs with Transform Step (TS) indicators not equal to 0 are true, LFNST mode is disapproved for the current CU. In another embodiment, when the block does not contain cbf (cbf equals false), the TS indicator will not be 1. For example, if a BDPCM block has no cbf, its TS indicator will not be inferred as 1. An example of the modified semantics according to one embodiment of the present invention is shown below. When transform_skip_flag[ xO ][ yO ][ cldx ] is not present, this is inferred as follows: -If BdpcmFlag[ xO ][ yO ][ cldx ] is equal to 1, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred as follows - If cldx = 0 and tu_cbf_luma[xO][yO] = 1, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred as equal to 1. - Otherwise, if cldx = 1 and tu_cbf_cb[xO][yO] = 1, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred to be equal to 1. - Otherwise, if cldx = 1 and tu_cbf_cr[xO][yO] = 1, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred to be equal to 1. - Otherwise, transform_skip_flag[ xO ][ yO ][ cldx ] is inferred as equal to 0. In another scenario, when chrominance LFNST is disabled in some cases, LfnstZeroOutSigCoeffFIag, which is initialized to 1 before analyzing each TB in a CU and is changed to 0 if any TB in that CU has any significant coefficients (or the last significant coefficient) located in the zero LFNST region, is not updated in non-LFNST TBs. For example, chrominance LFNST is disabled for a single tree. Afterward, non-LFNST TBs include the chrominance TBs for that single tree. An example of the corresponding changes in the syntax table is shown below. Table 22. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. residual_coding( xO, yO, log2TbWidth, log2TbHeight, cldx ) {... Descriptor s¡( lastSubBlock = = 0 && log2TbWidth >= 2 && log2TbHeight >= 2 && !transform_skip_flag[ xO ][ yO ][ cldx ] && lastScanPos > 0) LfnstDcOnly = 0 s¡( (lastSubBlock > 0 && log2TbWidth >= 2 && log2TbHeight >= 2 ) | | (lastScanPos > 7 && (log2TbWidth = = 2 | | log2TbWidth = = 3 ) && log2TbWidth = = log2TbHeight) && ((cldx == 0) || (treeType != SINGLE_TREE))) LfnstZeroOutSigCoeffFIag = 0} In another example, chrominance LFNSTs are disabled, and non-LFNST TBs include chrominance TBs. An example of the corresponding changes in the syntax table is shown below. Table 23. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. Residual_coding( xO, yO, log2TbWidth, log2TbHeight, cldx ) {... Descriptor s¡( lastSubBlock = = 0 && log2TbWidth >= 2 && log2TbHeight >= 2 && !transform_skip_flag[ xO ][ yO ][ cldx ] && lastScanPos > 0 ) LfnstDcOnly = 0 s¡( (lastSubBlock > 0 && log2TbWidth >= 2 && log2TbHeight >= 2 ) | | (lastScanPos > 7 && (log2TbWidth = = 2 11 log2TbWidth = = 3 ) && log2TbWidth = = log2TbHeight) &&( cldx = 0 )) LfnstZeroOutSigCoeffFIag = 0 ...} Based on Table 15, which means only checking the luminance transform_skip_flag when luminance TUs are encoded (e.g., not for Ln / zznz / E / YiAi DUAL_TREE_CHROMA) and only check the chrominance transform_skip flag when chrominance TUs are encoded (e.g., not for DUAL_TREE_LUMA). The chrominance LFNST is disabled in some cases. For example, for a single tree, the chrominance LFNST is disabled. An example of the proposed syntax table is shown below. Table 24. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. s¡( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && (treeType == DUAL_TREE_CHROMA? (transform_skipjlag[ xO ][ yO ][ 1] = = 0&& transform_skipjlag[ xO ][ yO ][ 2 ] = = 0) : (transform_skipjlag[ xO ][ yO ][ 0] = = 0))&& (treeType != DUALTREECHROMA || !¡ntra_mipjlag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >= 16 ) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISPNOSPLIT | | LfnstDcOnly = = 0) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} Another example of the proposed syntax table based on Table 16 is also represented as follows. Table 25. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. if( Min( IfnstWidth, IfnstHeight) >= 4 && sps_lfnst_enabled_flag == 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && (treeType == DUAL_TREE_CHROMA 11 transform_skipjlag[ xO ][ yO ][ 0 ] = = 0) && (treeType != DUAL_TREE_CHROMA 11 (transform_skipjlag[ xO ][ yO ][ 1 ] = = 0 && transform_skipflag[ xO ][ yO ][ 2 ] = = 0)) && (treeType == DUAL_TREE_CHROMA || !¡ntra_mip_flag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >= 16 ) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISP_NO_SPLIT | | LfnstDcOnly = = 0) && LfnstZeroOutSigCoeffFIag = = 1 ) Ln / zznz / E / YiAi Ifnstjdx ae(v)} In another example, chrominance LFNST is disabled. The proposed syntax table is shown below. An example of the proposed syntax table is shown below. Table 26. An exemplary signaling / analysis syntax table for LFNST according to an embodiment of the present invention. s¡( Min( IfnstWidth, IfnstHeight) >- 4 && spslfnstenabledflag = = 1 && CuPredMode[ chType ][ xO ][ yO ] = = MODEJNTRA && (treeType != DUAL TREE CHROMA && (transform_skip_flag[ xO ][ yO ][ 0] = = 0)) && (treeType != DUALTREECHROMA || !¡ntra_mip_flag[ xO ][ yO ] || Min( IfnstWidth, IfnstHeight) >= 16 ) && Max( cbWidth, cbHeight) <= MaxTbSizeY) { s¡( (IntraSubPartitionsSplitType != ISP NO SPLIT | | LfnstDcOnly = = 0) && LfnstZeroOutSigCoeffFIag = = 1 ) lfnst_idx ae(v)} In VVC Proposal 7, the LFNST and MTS indices are encoded at the end of the CU, which introduces latency and buffer memory problems because a decoder needs to place coefficients of all three color components into buffer memory before receiving the MTS and LFNST indices. To reduce these latency and buffer memory problems, it is proposed to send the MTS and / or LFNST enable indicator or index (e.g., 0 to disable, 1 and 2 to enable; 1 and 2 mean using a different primary transform or a different LFNST matrix) at the end of the first TB in a CU, or at the end of one or more TBs of the first color component, or at the end of the first non-zero TB (and non-transform jump TB) in a CU, or at the end of one or more TBs of the first color component (and non-transform jump TB). In another approach, it is proposed to send the MTS and / or LFNST enable indicator or index at the end of the first non-zero TB (and non-transform jump TB) in a CU, or at the end of one or more TBs of the first color component (and non-transform jump TB). In one example, this can be applied only to a single tree. In a single tree, the LFNST and MTS indices are signaled / analyzed after the luminance TB (or before the chrominance TBs). If both a single tree and ISP are applied, the LFNST and MTS indices are signaled / analyzed after the last luminance TB (or before the chrominance TBs). For example, the subTuIndex can be used. When the subTuIndex is equal to NumlntraSubPartitions - 1, the current TB is the luminance TB, and the current tree type is the unique tree, the MTS and LFNST indices are signaled / analyzed (if one or more conditions are met). In another approach, it is proposed to send the MTS and / or LFNST enablement indicator or index at the end of one or more luminance TBs in a CU (or before the chrominance TBs) in the case of a single tree; while in the dual luminance tree, the MTS and / or LFNST index is signaled / analyzed at the end of one or more luminance TBs in a CU (or at the end of the CU); while in the dual chrominance tree, the MTS and / or LFNST index is signaled / analyzed after the end of the chrominance TBs in a CU (or at the end of the CU). If the single tree and the ISP are applied, the LFNST and MTS indices are signaled / analyzed after the last luminance TB (or before the chrominance TBs). For example, the subTuIndex can be used. When the subTuIndex is equal to NumlntraSubPartitions - 1, the current TB is the luminance TB and the current tree type is the unique tree, the MTS and LFNST indices are signaled / analyzed (if one or more conditions are met). In another configuration, the MTS and / or LFNST enablement indicator or index is signaled / analyzed in the first TB (e.g., at the end of the first TB) when using ISP mode. The proposed method can only be applied to the single tree (e.g., still signaling / analyzing the MTS / LFNST index at the end of the CU in a dual luminance tree or dual chrominance tree). In the method mentioned above, the MTS index can be signaled / analyzed after the LFNST index. If the LFNST is used (e.g., the LFNST index is not 0), the MTS index is inferred to be 0. Alternatively, the LFNST can be signaled / analyzed after the MTS index has been signaled / analyzed. If the MTS is used (e.g., the MTS index is not 0), the LFNST index is inferred to be 0. Any of the methods proposed above can be combined. Any variations from the foregoing may be implicitly determined by block width, block height, or block area, or explicitly determined by a signaled / analyzed indicator in the CU, CTU, segment, mosaic, mosaic group, SPS, PPS, or at the image level. “Block” in this invention may mean TU / TB / CU / CB / PU / PB. Any of the proposed methods above can be implemented in encoders and / or decoders. For example, any of the proposed methods can be implemented in an encoder's inter-coding / intra-coding / transform coding module, a motion compensation module, or a decoder's fusion candidate derivation module. Alternatively, any of the proposed methods can be implemented as a circuit coupled to an encoder's inter-coding / intra-coding / transform coding module and / or motion compensation module, or a decoder's fusion candidate derivation module. The decoding process incorporating an embodiment of the present invention can be understood based on the disclosure described above. For the decoding process of a system incorporating LFNST, the input data consists of encoded data, including a CU that is being decoded. The decoding process then verifies the CBF indications based on the encoded data. An LFNST syntax is analyzed according to the verification result. The CU is then decoded according to the LFNST syntax. Figure 3 illustrates a flowchart of an exemplary decoding system incorporating LFNST (low-frequency non-separable transform) analysis according to an embodiment of the present invention. The steps shown in the flowchart can be implemented as executable program code on one or more processors (e.g., one or more CPUs) on the encoder side.The steps shown in the flowchart can also be implemented using hardware such as one or more electronic devices or processors arranged to execute the steps in the flowchart. As shown in Figure 3, input data related to a current encoding unit (CU) in a current image is received in step 310, where the current CU is partitioned into one or more transform blocks (TBs), and the input data corresponds to encoded data from the current CU. One or more Encoded Block Indicator (CBF) readings for one or more target TBs are checked against the encoded data in step 320. An LFNST syntax is analyzed if one or more conditions are met in step 330, where the LFNST syntax indicates whether the LFNST mode is applied to the current CU and / or which LFNST kernel is applied when the LFNST mode is applied, and these conditions include the target TB(s) being false. The current CU is decoded according to the LFNST mode as indicated by the LFNST syntax in step 340. The encoding process incorporating a modality of the present invention can be understood based on the disclosure described above. For the encoding process for a system incorporating LFNST, the input data for LFNST are primary transformed data. The encoding process then applies LFNST based on an LFNST kernel. Ln / zznz / E / YiAi is used to derive temporary output data. For example, if the check passes, the LFNST syntax is signaled. In another example, if the check fails (and the TS check also fails), the LFNST syntax is forced to zero. An LFNST syntax is determined and signaled according to the check result. The current CU is then encoded according to the determined LFNST syntax. Figure 4 illustrates a flowchart of an exemplary encoding system incorporating LFNST (low-frequency non-separable transform) analysis according to an embodiment of the present invention. As shown in Figure 4, input data related to a current encoding unit (CU) in a current image are received in step 410, where the current CU is partitioned into one or more transform blocks (TB), and the input data corresponds to the primary transformed data. The LFNST process is applied based on an LFNST kernel to derive temporary output data in step 420.An LFNST syntax is determined and signaled if one or more conditions in step 430 are met, where the LFNST syntax indicates whether the LFNST mode is applied to the current CU and / or which LFNST kernel is applied when the LFNST mode is applied, and that condition(s) comprise one or more Coded Block Indicator (CBF) readings for one or more target transform (TB) blocks that are false. The current CU is coded according to the LFNST mode as indicated by the LFNST syntax determined in step 440. The flowchart shown is intended to illustrate an example of video encoding / decoding according to the present invention. A person skilled in the art may modify each step, rearrange steps, divide a step, or combine steps to practice the present invention without departing from the spirit of the present invention. In this disclosure, specific syntax and semantics have been used to illustrate examples for implementing modalities of the present invention. A person skilled in the art may practice the present invention by substituting the syntax and semantics with equivalent syntax and semantics without departing from the spirit of the present invention. The foregoing description is presented to enable a person skilled in the art to practice the present invention as set forth in the context of a particular application and its requirements. Several modifications to the described embodiments will be apparent to such persons skilled in the art, and the general principles defined herein may be applied to other embodiments. Therefore, the present invention is not intended to be limited to the particular embodiments shown and described, but rather to have the broadest scope consistent with the novel principles and features disclosed herein. In the detailed description above, several specific details are illustrated to provide a complete understanding of the present invention. Nevertheless, those skilled in the art will readily understand that the present invention can be practiced. The embodiment of the present invention, as described above, can be implemented in a variety of hardware, software, or a combination of both. For example, one embodiment of the present invention may be one or more integrated circuits on a video compression chip or program code embedded in video compression software to perform the processing described herein. Another embodiment of the present invention may be program code to be executed on a Digital Signal Processor (DSP) to perform the processing described herein. The invention may also involve a number of functions to be executed by a computer processor, a digital signal processor, a microprocessor, or a field-programmable gate array (FPGA).These processors can be configured to perform specific tasks according to the invention by executing machine-readable software code or firmware code that defines the specific methods incorporated by the invention. The software code or firmware code can be developed in different programming languages ​​and formats or styles. The software code can also be compiled for different target platforms. However, different code formats, styles, and languages, and other means of configuring code to perform the tasks according to the invention, will not depart from the spirit and scope of the invention. The embodiment of the present invention, as described above, can be implemented in a video encoder and a video decoder.The components of a video encoder and decoder can be implemented by hardware components, one or more processors configured to execute program instructions stored in memory, or a combination of hardware and processor. For example, a processor executes program instructions to control the reception of input data associated with a video sequence, including a current block within a current frame. The processor is equipped with a single processing core or multiple processing cores. In some examples, the processor executes program instructions to perform functions in certain components of the encoder and decoder, and memory electrically coupled to the processor is used to store the program instructions, information corresponding to the reconstructed block frames, and / or intermediate data during the encoding or decoding process.Memory, in a certain sense, includes a non-transient, computer-readable medium, such as a semiconductor or solid-state memory, random-access memory (RAM), read-only memory (ROM), a hard disk, an optical disk, or other convenient storage medium. The nAcn Ln / zznz / E / YiAi. Ln / zznz / E / YiAi memory can also be a combination of two or more of the non-transient computer-readable media listed above. The invention may be incorporated in other specific forms without departing from its spirit or essential characteristics. The examples described are to be considered in all respects as illustrative only and not restrictive. The scope of the invention is then indicated by the appended claims instead of the preceding description. All changes arising within the meaning and range of equivalence of the claims shall be encompassed within their scope.

Claims

1. A method for decoding a video sequence, characterized in that it supports a low-frequency non-separable transform (LFNST) mode, wherein the method comprises: receiving input data relating to a current encoding unit (CU) in a current image, wherein the current CU is partitioned into one or more transform blocks (TB) and the input data corresponds to encoded data from the current CU; checking one or more Encoded Block Indicator (CBF) readings for one or more target TBs based on the encoded data; analyzing an LFNST syntax if one or more conditions are met, wherein the LFNST syntax indicates whether the LFNST mode is applied to the current CU and / or which LFNST kernel is applied when the LFNST mode is applied, and such condition(s) comprise one or more CBF readings for one or more target TBs that are false;and decode the current CU according to the LFNST mode as indicated by the LFNST syntax.; 2. The method according to claim 1, characterized in that the target TB or TBs correspond to one or more TBs with Transform Jump (TS) indicators not equal to 0.

3. The method according to claim 1, characterized in that, in a luminance split tree, the current CU corresponds to a luminance encoding block, and that target TB or those TBs correspond to one or more luminance TBs.

4. The method according to claim 1, characterized in that, in a chrominance split tree, the current CU corresponds to one or more chrominance coding blocks, and that target TB(s) correspond to one or more chrominance TB(s).

5. The method according to claim 1, characterized in that in a single split tree, the current CU corresponds to a luminance encoding block and one or more chrominance encoding blocks, and that target TB(s) correspond to one or more luminance TB(s) and one or more chrominance TB(s).

6. The method according to claim 1, characterized in that the target TB or TBs correspond to a predefined TB for each encoding block in the current CU.

7. The method according to claim 6, characterized in that the predefined TB corresponds to the first TB for each encoding block in the current CU.

8. The method according to claim 1, characterized in that if all such CBF indications for such target TB(s) are false, the LFNST mode is permitted for the current CU.

9. The method according to claim 1, characterized in that if all such CBF indications for that target TB or those TBs are false and that target TB or those TBs indicate one or more TBs having Transform Jump (TS) indicators not equal to 0, the LFNST mode is permitted for the current CU.

10. The method according to claim 1, characterized in that if any of those CBF indications for that or those target TB with Transform Jump (TS) indicators not equal to 0 is true, the LFNST mode is disapproved for the current CU.

11. An apparatus for decoding a video sequence, characterized in that it supports a Low Frequency Non-Separable Transform (LFNST) mode, wherein the apparatus comprises one or more electronic circuits or processors arranged to: receive input data relating to an actual encoding unit (CU) in an actual picture, wherein the actual CU is partitioned into one or more transform blocks (TB) and the input data corresponds to encoded data from the actual CU; check one or more Encoded Block Indicator (CBF) readings for one or more target TBs based on the encoded data; analyze an LFNST syntax if one or more conditions are met, wherein the LFNST syntax indicates whether the LFNST mode is applied to the actual CU and / or which LFNST kernel is applied when the LFNST mode is applied, and such condition(s) comprise such CBF reading(s) for such target TB(s) being false;and decode the current CU according to the LFNST mode as indicated by the LFNST syntax.; 12. A method for encoding a video sequence, characterized in that it supports a low-frequency non-separable transform (LFNST) mode, wherein the method comprises: receiving input data relating to a current encoding unit (CU) in a current image, wherein the current CU is partitioned into one or more transform blocks (TB) and the input data corresponds to primary transformed data; applying the LFNST process based on an LFNST kernel to derive temporary output data; determining and signaling an LFNST syntax in the event that one or more conditions are satisfied, wherein the LFNST syntax indicates whether the LFNST mode is applied to the current CU Ln / zznz / E / YiAi and / or which LFNST kernel is applied when the LFNST mode is applied, and such condition(s) comprise one or more Encoded Block Indicator (CBF) indications for one or more target transform blocks (TB) that are false;and encode the current CU according to the LFNST mode as indicated by the determined LFNST syntax.; 13. An apparatus for encoding a video sequence, characterized in that it supports a Low Frequency Non-Separable Transform (LFNST) mode, wherein the apparatus comprises one or more electronic circuits or processors arranged to: receive input data relating to an actual encoding unit (CU) in an actual picture, wherein the actual CU is partitioned into one or more transform blocks (TB) and the input data corresponds to primary transformed data; apply the LFNST process based on an LFNST kernel to derive temporary output data; determine and signal an LFNST syntax in the event that one or more conditions are satisfied, wherein the LFNST syntax indicates whether the LFNST mode is applied to the actual CU and / or which LFNST kernel is applied when the LFNST mode is applied, and such condition(s) comprise one or more Encoded Block Indicator (CBF) indications for one or more target transform blocks (TB) that are false;and encode the current CU according to the LFNST mode as indicated by the determined LFNST syntax.;

Images