Palette modes with different segmentation structures

Abstract

Methods, systems, and devices for using a palette mode in combination with different partitioning structures are described. An example of a method for video processing includes: maintaining a palette prediction table for predicting a palette used in a palette mode coding / decoding tool used for a current video block for a conversion between a video including one or more video regions including the current video block and a bitstream representation of the video; making a decision to apply local double-tree coding / decoding to the conversion; modifying the palette prediction table based on the decision; and performing the conversion based on the modified palette prediction table, wherein the palette mode coding / decoding tool represents a palette of representative color values for the current video block, and wherein local double-tree coding / decoding is capable of partitioning chrominance blocks independently of corresponding luma blocks based on block size.

Description

[0001] Cross - reference to Related Applications

[0002] This application is a national stage application in China of international patent application No. PCT / US2020 / 046574 filed on August 15, 2020. This application claims the priority and benefits of international patent applications numbered PCT / CN2019 / 100850 filed on August 15, 2019 and PCT / CN2019 / 113931 filed on October 29, 2019 in a timely manner. The entire disclosure of the foregoing applications is incorporated herein by reference as part of the disclosure of this application. Technical Field

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

[0004] Digital video occupies the largest bandwidth usage on the Internet and other digital communication networks. With the increase in the number of connected user devices capable of receiving and displaying video, it is expected that the bandwidth demand for digital video will continue to grow. Summary of the Invention

[0005] The disclosed technology can be implemented by video or image decoder or encoder embodiments for using a palette mode in combination with different segmentation structures.

[0006] In one exemplary aspect, a video processing method is disclosed. The method includes: maintaining a palette prediction table for predicting a palette used in a palette mode codec tool for a current video block for a conversion between a video including one or more video regions including the current video block and a bitstream representation of the video; making a decision to apply local dual - tree codec to the conversion; modifying the palette prediction table based on the decision; and performing the conversion based on the modified palette prediction table, wherein the palette mode codec tool represents a palette of representative color values for the current video block, and wherein local dual - tree codec can segment a chrominance block independently of a corresponding luma block based on block size.

[0007] In another exemplary aspect, a method of video processing is disclosed. The method includes: performing a conversion between a video including one or more video regions including the current video block and a bitstream representation of the video, wherein the bitstream representation conforms to format rules that prohibit the simultaneous use of palette mode codec and local dual - tree codec for the current video block, wherein the palette mode codec tool represents a palette of representative color values for the current video block, and wherein local dual - tree codec can segment a chrominance block independently of a corresponding luma block based on block size.

[0008] In yet another exemplary aspect, a method for video processing is disclosed. The method includes: performing a conversion between a video including one or more video regions including a current video block and a bitstream representation of the video, wherein the video block is encoded and decoded into the bitstream representation using a palette codec mode, in which the video block is represented using a palette of representative color values, and wherein a palette prediction table for predicting a palette is selectively used for the conversion based on a condition.

[0009] In yet another exemplary aspect, the above method may be implemented by a video encoder device including a processor.

[0010] In yet another exemplary aspect, the above method may be implemented by a video decoder device including a processor.

[0011] In yet another exemplary aspect, these methods may be embodied in the form of processor-executable instructions and stored on a computer-readable program medium.

[0012] These aspects and other aspects are further described herein. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 An example of a block encoded and decoded in a palette mode is shown.

[0014] Figure 2 An example of signaling a palette entry using a palette predictor is shown.

[0015] Figure 3 Examples of horizontal and vertical traversal scans are shown.

[0016] Figure 4 An exemplary encoding and decoding of a palette index is shown.

[0017] Figure 5A and Figure 5B An example of a minimum chroma intra prediction unit (SCIPU) is shown.

[0018] Figure 6 A block diagram of an example of in-loop filtering in video processing is shown.

[0019] Figure 7 An example of repeated palette entries in a local double-tree case is shown.

[0020] Figure 8 Examples of a left block and an upper block in a context derivation process are shown.

[0021] Figure 9 A block diagram of an example of a hardware platform for implementing the techniques described in this document is shown.

[0022] Figure 10 is a block diagram of an exemplary video processing system that can implement the disclosed technology.

[0023] Figure 11 is a block diagram showing a video coding system according to some embodiments of the present disclosure.

[0024] Figure 12 is a block diagram showing an encoder according to some embodiments of the present disclosure.

[0025] Figure 13 is a block diagram showing a decoder according to some embodiments of the present disclosure.

[0026] Figures 14 - 16 shows a flowchart of an exemplary method of video processing. Detailed Description

[0027] This document provides various techniques that a decoder of an image or video bitstream can use to improve the quality of decompressing or decoding digital video or images. For brevity, the term "video" is used herein to include both a sequence of pictures (conventionally referred to as video) and individual images. In addition, a video encoder can also implement these techniques during the encoding process to reconstruct decoded frames for further encoding.

[0028] Section headings are used in this document for ease of understanding and are not intended to limit the embodiments and techniques to the corresponding sections. Accordingly, embodiments from one section can be combined with embodiments from other sections.

[0029] 1. Overview

[0030] This document relates to video coding techniques. Specifically, this document relates to index and escape symbol coding and decoding in palette coding and decoding. It can be applied to existing video coding standards such as HEVC, or to standards under consideration (Versatile Video Coding). It can also be applicable to future video coding standards or video codecs.

[0031] 2. Background

[0032] Video coding standards have evolved mainly through the development of well-known ITU-T and ISO / IEC standards. ITU-T developed H.261 and H.263, ISO / IEC developed MPEG-1 and MPEG-4 Visual, and the two organizations jointly developed H.262 / MPEG-2 Video, H.264 / MPEG-4 Advanced Video Coding (AVC), and H.265 / HEVC standards. Since H.262, video coding standards have been based on a hybrid video coding structure, where temporal prediction plus transform coding is employed. To explore future video coding technologies beyond HEVC, VCEG and MPEG jointly established the Joint Video Exploration Team (JVET) in 2015. Since then, JVET has adopted many new methods and applied them to a reference software called the Joint Exploration Model (JEM). In April 2018, the Joint Video Experts Team (JVET) was created between VCEG (Q6 / 16) and ISO / IEC JTC1 SC29 / WG11 (MPEG), which is dedicated to researching the VVC standard targeting a 50% bitrate reduction compared to HEVC.

[0033] The latest version of the VVC draft, namely Versatile Video Coding (Draft 6), can be found at the following URL:

[0034] http: / / phenix.it-sudparis.eu / jvet / doc_end_user / documents / 15_Gothenburg / wg11 / JVET-O2001-v14.zip

[0035] The latest reference software for VVC, called VTM, can be found at the following URL:

[0036] https: / / vcgit.hhi.fraunhofer.de / jvet / VVCSoftware_VTM / tags / VTM-5.0

[0037] 2.1 Palette Mode in High Efficiency Video Coding Screen Content Coding Extension (HEVC-SCC)

[0038] 2.1.1 Concept of Palette Mode

[0039] The basic idea behind the palette mode is to represent the pixels in a CU by a small set of representative color values. This set is called the palette. It is also possible to signal escape symbols and subsequent (possibly quantized) component values to indicate samples outside the palette. Such pixels are called escape pixels. The palette mode is illustrated in Figure 1 as Figure 1As shown, for each pixel having three color components (a luminance component and two chrominance components), an index to the palette is found and the block can be reconstructed based on the values found in the palette.

[0040] 2.1.2 Encoding of Palette Entries

[0041] To encode and decode palette entries, a palette predictor is maintained. The maximum size of the palette and the palette predictor are signaled in the SPS. In HEVC-SCC, palette_predictor_initializer_present_flag is introduced in the PPS. When this flag is 1, the entries used to initialize the palette predictor are signaled in the bitstream. The palette predictor is initialized at the start of each CTU row, each slice, and each tile. Depending on the value of palette_predictor_initializer_present_flag, the palette predictor is reset to 0 or initialized using the palette predictor initializer entries signaled in the PPS. In HEVC-SCC, a palette predictor initializer of size 0 is enabled to allow explicit disabling of palette predictor initialization at the PPS level.

[0042] For each entry in the palette predictor, a reuse flag is signaled to indicate whether it is part of the current palette. This is illustrated in Figure 2 The reuse flag is sent using run-length encoding of zeros. After that, the number of new palette entries is signaled using a 0th order Exponential Golomb (EG) code (i.e., EG-0). Finally, the component values for the new palette entries are signaled.

[0043] 2.1.3 Encoding of Palette Indexes

[0044] Horizontal and vertical traversal scans as shown in Figure 3 are used to encode and decode palette indexes. The scan order is explicitly signaled in the bitstream using palette_transpose_flag. For the remainder of this subsection, it is assumed that the scan is horizontal.

[0045] Two palette sample modes, "COPY_LEFT" and "COPY_ABOVE", are used to encode and decode palette indexes. In the "COPY_LEFT" mode, the palette index is assigned to the decoded index. In the "COPY_ABOVE" mode, the palette index of the sample in the above row is copied. For both the "COPY_LEFT" and "COPY_ABOVE" modes, a run value is signaled that specifies the number of subsequent samples that are also encoded using the same mode.

[0046] In the palette mode, the value of the index for the escape symbol is the number of palette entries. Also, when the escape symbol is a part operating in the "COPY_LEFT" or "COPY_ABOVE" mode, the escape component value is signaled for each escape symbol. Figure 4 The encoding and decoding of the palette index are shown.

[0047] This syntax order is completed as follows. First, the number of index values of the CU is signaled. After that, the actual index values of the entire CU are signaled using truncated binary coding. Both the index number and the index value are encoded in the bypass mode. In this way, the bypass binary bits (bins) related to the index are grouped together. Then, the palette sample mode (if necessary) and the run are signaled in an alternating manner. Finally, the component escape values corresponding to the escape symbols of the entire CU are grouped together and encoded and decoded in the bypass mode. The binarization of the escape symbol is 3rd order exponential-Golomb coding, i.e., EG-3.

[0048] After signaling the index values, the additional syntax element last_run_type_flag is signaled. This syntax element, combined with the index number, eliminates the need to signal the run value corresponding to the last run in the block.

[0049] In HEVC-SCC, the palette mode is also enabled for 4:2:2, 4:2:0, and monochrome chroma formats. The signaling of the palette entries and the palette index is almost the same for all chroma formats. For non-monochrome formats, each palette entry consists of 3 components. For monochrome formats, each palette entry consists of a single component. For subsampled chroma directions, the chroma samples are associated with the luminance sample indices divisible by 2. After reconstructing the palette index for the CU, if a sample has only a single component associated with it, only the first component of the palette entry is used. The only difference in the signaling is for the escape component values. For each escape symbol, the number of escape component values signaled can be different according to the number of components associated with the symbol.

[0050] In addition, there is an index adjustment process in the palette index coding. When signaling the palette index, the left adjacent index or the above adjacent index should be different from the current index. Therefore, the range of the current palette index can be reduced by 1 by removing one possibility. Then, the truncated binary code (TB) is used to binarize and signal the index.

[0051] The following shows the text related to this part, where CurrPaletteIndex is the current palette index and adjustedRefPaletteIndex is the predicted index.

[0052] The variable PaletteIndexMap[xC][yC] specifies a palette index, which is an index into the array represented by CurrentPaletteEntries. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luminance sample of the picture. The value of PaletteIndexMap[xC][yC] must be in the range from 0 to MaxPaletteIndex, inclusive of the endpoints.

[0053] The variable adjustedRefPaletteIndex is derived as follows:

[0054]

[0055] When CopyAboveIndicesFlag[xC][yC] is equal to 0, the variable CurrPaletteIndex is derived as follows:

[0056] if (CurrPaletteIndex >= adjustedRefPaletteIndex)

[0057] CurrPaletteIndex++

[0058] In addition, context encoding and decoding are performed on the run-length elements in the palette mode. The relevant context derivation process described in JVET-O2011-vE is shown below.

[0059] Derivation process of ctxInc for the syntax element palette_run_prefix The input to this process is the binary index binIdx and the syntax elements copy_above_palette_indices_flag and palette_idx_idc.

[0060] The output of this process is the variable ctxInc.

[0061] The variable ctxInc is derived as follows:

[0062] – If copy_above_palette_indices_flag is equal to 0 and binIdx is equal to 0, then ctxInc is derived as follows:

[0063] ctxInc = (palette_idx_idc < 1)? 0 : ((palette_idx_idc < 3)? 1 : 2) (9-69)

[0064] – Otherwise, ctxInc is provided by Table 1:

[0065] Specification of Table 1 – ctxIdxMap[copy_above_palette_indices_flag][binIdx]

[0066]

[0067] 2.2 Palette Mode in VVC

[0068] 2.2.1 Palette in Dual-Tree

[0069] In VVC, a dual-tree structure is used when encoding intra-bands, so that the luminance component and the two chrominance components can have different palettes and palette indices. In addition, the two chrominance components share the same palette and palette index.

[0070] 2.2.2 Palette as a Separate Mode

[0071] In JVET-N0258 and the current VTM, the prediction modes for the coding / decoding unit can be MODE_INTRA, MODE_INTER, MODE_IBC, and MODE_PLT. Accordingly, the binarization of the prediction mode is changed.

[0072] When IBC is turned off, on I slices, the first binary bit is used to indicate whether the current prediction mode is MODE_PLT. On P / B slices, the first binary bit is used to indicate whether the current prediction mode is MODE_INTRA. If not, then an additional binary bit is used to indicate that the current prediction mode is MODE_PLT or MODE_INTER.

[0073] When IBC is turned on, on I slices, the first binary bit is used to indicate whether the current prediction mode is MODE_IBC. If not, then the second binary bit is used to indicate whether the current prediction mode is MODE_PLT or MODE_INTRA. On P / B slices, the first binary bit is used to indicate whether the current prediction mode is MODE_INTRA. If it is an intra mode, then the second binary bit is used to indicate whether the current prediction mode is MODE_PLT or MODE_INTRA. If not, then the second binary bit is used to indicate whether the current prediction mode is MODE_IBC or MODE_INTER.

[0074] The relevant text in JVET-O2001-vE is shown below.

[0075] Coding / Decoding Unit Syntax

[0076]

[0077]

[0078] 2.2.3 Palette Mode Syntax

[0079]

[0080]

[0081]

[0082]

[0083]

[0084] 2.2.4 Palette Mode Semantics

[0085] In the semantics below, the array indices x0, y0 specify the position (x0, y0) of the top-left luminance sample of the coding block under consideration relative to the top-left luminance sample of the picture. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luminance sample of the picture. The array index startComp specifies the first color component of the current palette table. startComp equal to 0 indicates the Y component; startComp equal to 1 indicates the Cb component; startComp equal to 2 indicates the Cr component. numComps specifies the number of color components in the current palette table.

[0086] The predictor palette is composed of palette entries from the previous coded units used to predict the entries in the current palette.

[0087] The variable PredictorPaletteSize[startComp] specifies the size of the predictor palette for the first color component startComp of the current palette table. PredictorPaletteSize is derived as specified in Clause 8.4.5.3.

[0088] The variable PalettePredictorEntryReuseFlags[i] equal to 1 specifies that the i-th entry in the predictor palette is reused in the current palette. PalettePredictorEntryReuseFlags[i] equal to 0 specifies that the i-th entry in the predictor palette is not an entry in the current palette. All elements of the array PalettePredictorEntryReuseFlags[i] are initialized to 0.

[0089] Use palette_predictor_run to determine the number of zeros before a non-zero entry in the array PalettePredictorEntryReuseFlags.

[0090] The requirement for bitstream consistency is that the value of palette_predictor_run must be in the range from 0 to (PredictorPaletteSize - predictorEntryIdx) (including the endpoints), where predictorEntryIdx corresponds to the current position in the array PalettePredictorEntryReuseFlags. The variable NumPredictedPaletteEntries specifies the number of entries from the predictor palette that are reused in the current palette. The value of NumPredictedPaletteEntries must be in the range from 0 to palette_max_size (including the endpoints).

[0091] num_signalled_palette_entries specifies the number of entries in the current palette that are explicitly signaled for the first color component startComp of the current palette table.

[0092] In the absence of num_signalled_palette_entries, it is inferred to be equal to 0.

[0093] The variable CurrentPaletteSize[startComp] specifies the size of the current palette for the first color component startComp of the current palette table, and this variable is derived as follows:

[0094] CurrentPaletteSize[startComp] = NumPredictedPaletteEntries +

[0095] num_signalled_palette_entries(7 - 155)

[0096] The value of CurrentPaletteSize[startComp] must be in the range from 0 to palette_max_size (including the endpoints).

[0097] new_palette_entries[cIdx][i] specifies the value of the i-th signaled palette entry for color component cIdx.

[0098] The variable PredictorPaletteEntries[cIdx][i] specifies the i-th element in the predictor palette for color component cIdx.

[0099] The variable CurrentPaletteEntries[cIdx][i] specifies the i-th element in the current palette for color component cIdx, and this variable is derived as follows:

[0100]

[0101]

[0102] The palette_escape_val_present_flag being equal to 1 specifies that the current coding unit contains at least one escaped coded sample. The escape_val_present_flag being equal to 0 specifies that there are no escaped coded samples in the current coding unit. When the palette_escape_val_present_flag is not present, its value is inferred to be equal to 1.

[0103] The variable MaxPaletteIndex specifies the maximum possible value of the palette index for the current coding unit. Set the value of MaxPaletteIndex to be equal to

[0104] CurrentPaletteSize[startComp] - 1 + palette_escape_val_present_flag.

[0105] num_palette_indices_minus1 plus 1 is the number of palette indices explicitly signaled or inferred for the current block.

[0106] When num_palette_indices_minus1 is not present, it is inferred to be equal to 0.

[0107] palette_idx_idc is an indication of the index into the palette table CurrentPaletteEntries. The value of palette_idx_idc must be in the range from 0 to MaxPaletteIndex (inclusive of the endpoints) for the first index in the block, and in the range from 0 to (MaxPaletteIndex - 1) (inclusive of the endpoints) for the remaining indices in the block.

[0108] When palette_idx_idc is not present, it is inferred to be equal to 0.

[0109] The variable PaletteIndexIdc[i] stores the i-th palette_idx_idc of an explicit signaling notification or an inference. Initialize all elements of the array PaletteIndexIdc[i] to 0.

[0110] copy_above_indices_for_final_run_flag being equal to 1 specifies that if a horizontal traversal scan is used, then copy the palette index at the last position in the current coding unit from the palette indices in the upper row; if a vertical traversal scan is used, then copy the palette index at the last position in the current coding unit from the palette indices in the left column.

[0111] copy_above_indices_for_final_run_flag being equal to 0 specifies to copy the palette index at the last position in the current coding unit from PaletteIndexIdc[num_palette_indices_minus1].

[0112] When copy_above_indices_for_final_run_flag does not exist, infer it to be equal to 0.

[0113] palette_transpose_flag being equal to 1 specifies to apply a vertical traversal scan to scan the indices of samples in the current coding unit. palette_transpose_flag being equal to 0 specifies to apply a horizontal traversal scan to scan the indices of samples in the current coding unit. When palette_transpose_flag does not exist, infer its value to be equal to 0.

[0114] The array TraverseScanOrder specifies the scan order array for palette coding. If palette_transpose_flag is equal to 0, then assign the horizontal scan order HorTravScanOrder to TraverseScanOrder, and if palette_transpose_flag is equal to 1, then assign the vertical scan order VerTravScanOrder to TraverseScanOrder.

[0115] A copy_above_palette_indices_flag equal to 1 specifies that if a horizontal traversal scan is used, then the palette index is equal to the palette index at the same position in the row above; if a vertical traversal scan is used, then the palette index is equal to the palette index at the same position in the column to the left. A copy_above_palette_indices_flag equal to 0 specifies that the indication of the palette index of the sample is encoded / decoded into the bitstream representation or that the indication is inferred.

[0116] A variable CopyAboveIndicesFlag[xC][yC] equal to 1 specifies that the palette index is copied from the palette index in the row above (horizontal scan) or the column to the left (vertical scan). A CopyAboveIndicesFlag[xC][yC] equal to 0 specifies that the palette index is explicitly encoded / decoded into the bitstream or that the palette index is inferred. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luma sample of the picture. The value of PaletteIndexMap[xC][yC] must be in the range from 0 to (MaxPaletteIndex–1) (inclusive of the endpoints).

[0117] A variable PaletteIndexMap[xC][yC] specifies the palette index, which is an index into the array represented by CurrentPaletteEntries. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luma sample of the picture. The value of PaletteIndexMap[xC][yC] must be in the range from 0 to MaxPaletteIndex (inclusive of the endpoints).

[0118] The variable adjustedRefPaletteIndex is derived as follows:

[0119]

[0120]

[0121] When CopyAboveIndicesFlag[xC][yC] is equal to 0, the variable CurrPaletteIndex is derived as follows:

[0122] if(CurrPaletteIndex >= adjustedRefPaletteIndex)

[0123] CurrPaletteIndex++(7-158)

[0124] The palette_run_prefix, when present, specifies the prefix part in the binarization of PaletteRunMinus1.

[0125] The palette_run_suffix is used in the derivation of the variable PaletteRunMinus1. When the palette_run_suffix is absent, its value is inferred to be equal to 0.

[0126] When RunToEnd is equal to 0, the variable PaletteRunMinus1 is derived as follows:

[0127] – If PaletteMaxRunMinus1 is equal to 0, then PaletteRunMinus1 is set to be equal to 0.

[0128] – Otherwise (PaletteMaxRunMinus1 is greater than 0), then the following applies:

[0129] – If palette_run_prefix is less than 2, then the following applies:

[0130] PaletteRunMinus1 = palette_run_prefix (7 - 159)

[0131] – Otherwise (palette_run_prefix is greater than or equal to 2), then the following applies:

[0132] PrefixOffset = 1 << (palette_run_prefix - 1)

[0133] PaletteRunMinus1 = PrefixOffset + palette_run_suffix (7 - 160)

[0134] The variable PaletteRunMinus1 is derived as follows:

[0135] – If CopyAboveIndicesFlag[xC][yC] is equal to 0, then PaletteRunMinus1 specifies the number of consecutive positions with the same palette index minus one.

[0136] – Otherwise, if palette_transpose_flag is equal to 0, then PaletteRunMinus1 specifies the number of consecutive positions with the same palette index minus one as used among the corresponding positions in the row above.

[0137] – Otherwise, PaletteRunMinus1 specifies the number of consecutive positions with the same palette index used among the corresponding positions in the left column minus one.

[0138] When RunToEnd is equal to 0, the variable PaletteMaxRunMinus1 represents the maximum possible value of PaletteRunMinus1, and the requirement for bitstream consistency is that the value of PaletteMaxRunMinus1 must be greater than or equal to 0.

[0139] palette_escape_val specifies the quantized escape coding sample value of a component.

[0140] The variable PaletteEscapeVal[cIdx][xC][yC] specifies the escape value of a sample for which PaletteIndexMap[xC][yC] is equal to MaxPaletteIndex and palette_escape_val_present_flag is equal to 1. The array index cIdx specifies the color component. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luminance sample of the picture.

[0141] The requirement for bitstream consistency is that for cIdx equal to 0, PaletteEscapeVal[cIdx][xC][yC] must be in the range from 0 to (1<<(BitDepthY+1))-1 (including the endpoints); for cIdx not equal to 0, PaletteEscapeVal[cIdx][xC][yC] must be in the range from 0 to (1<<(BitDepthC+1))-1 (including the endpoints).

[0142] 1.1.1 Line-based CG palette mode

[0143] VVC has adopted a line-based CG palette mode. In this method, each CU in the palette mode is divided into multiple segments consisting of m samples (m = 16 in this test) based on a traversal scan pattern. The encoding order of the palette run encoding in each segment is as follows: for each pixel, if the pixel has the same mode as the previous pixel, that is, if both the previously scanned pixel and the current pixel have the run type COPY_ABOVE, or if both the previously scanned pixel and the current pixel have the run type INDEX and have the same index value, then signal a context-coded binary bit run_copy_flag = 0. Otherwise, signal run_copy_flag = 1. If the pixel and the previous pixel have different modes, then signal a context-coded binary bit copy_above_palette_indices_flag to indicate the run type of the pixel, i.e., INDEX or COPY_ABOVE. Similar to the palette mode in VTM6.0, if the sample is within the first row (horizontal traversal scan) or the first column (vertical traversal scan), then the decoder does not have to parse the run type because the INDEX mode is used by default. Also, if the previously parsed run type is COPY_ABOVE, then the decoder does not have to parse the run type. After the palette run encoding of the pixels in a segment, except for the encoding / parsing of the context-coded binary bits, the index values (for the INDEX mode) and the quantized escape colors are bypass-coded and grouped together to improve the throughput within each line of CG. Since the index values are now encoded / parsed after the run encoding instead of being processed before the palette run encoding as in VTM, the encoder does not have to signal the number of index values num_palette_indices_minus1 and the last run type copy_above_indices_for_final_run_flag.

[0144] The text of the line-based CG palette mode in JVET-P0077 is shown below.

[0145] Palette coding / decoding syntax

[0146]

[0147]

[0148]

[0149]

[0150] 7.4.9.6. Palette coding / decoding semantics

[0151] In the following semantics, the array indices x0, y0 specify the position (x0, y0) of the top-left luma sample of the codec block under consideration relative to the top-left luma sample of the picture. The array indices xC, yC specify the position (xC, yC) of a sample relative to the top-left luma sample of the picture. The array index startComp specifies the first color component of the current palette table. startComp equal to 0 indicates the Y component; startComp equal to 1 indicates the Cb component; startComp equal to 2 indicates the Cr component. numComps specifies the number of color components in the current palette table.

[0152] The predictor palette is composed of palette entries from previously decoded units that are used to predict the entries in the current palette.

[0153] The variable PredictorPaletteSize[startComp] specifies the size of the predictor palette for the first color component startComp of the current palette table. PredictorPaletteSize is derived as specified in Clause 8.4.5.3.

[0154] The variable PalettePredictorEntryReuseFlags[i] equal to 1 specifies that the i-th entry in the predictor palette is reused in the current palette. PalettePredictorEntryReuseFlags[i] equal to 0 specifies that the i-th entry in the predictor palette is not an entry in the current palette. All elements of the array PalettePredictorEntryReuseFlags[i] are initialized to 0.

[0155] The number of zeros before the non-zero entries in the array PalettePredictorEntryReuseFlags is determined using palette_predictor_run.

[0156] The requirement for bitstream consistency is that the value of palette_predictor_run must be within the range of 0 to (PredictorPaletteSize - predictorEntryIdx) (including the endpoints), where predictorEntryIdx corresponds to the current position in the array PalettePredictorEntryReuseFlags. The variable NumPredictedPaletteEntries specifies the number of entries from the predictor palette that are reused in the current palette. The value of NumPredictedPaletteEntries must be within the range of 0 to palette_max_size (including the endpoints).

[0157] num_signalled_palette_entries specifies the number of entries in the current palette that are explicitly signaled for the first color component startComp of the current palette table.

[0158] In the absence of num_signalled_palette_entries, it is inferred to be equal to 0.

[0159] The variable CurrentPaletteSize[startComp] specifies the size of the current palette for the first color component startComp of the current palette table, and this variable is derived as follows:

[0160] CurrentPaletteSize[startComp] = NumPredictedPaletteEntries +

[0161] num_signalled_palette_entries(7 - 155)

[0162] The value of CurrentPaletteSize[startComp] must be within the range of 0 to palette_max_size (including the endpoints).

[0163] new_palette_entries[cIdx][i] specifies the value of the i-th signaled palette entry for color component cIdx.

[0164] The variable PredictorPaletteEntries[cIdx][i] specifies the i-th element in the predictor palette for color component cIdx.

[0165] The variable CurrentPaletteEntries[cIdx][i] specifies the i-th element in the current palette for color component cIdx, and this variable is derived as follows:

[0166]

[0167] A palette_escape_val_present_flag equal to 1 specifies that the current coding unit contains at least one escape-coded sample. An escape_val_present_flag equal to 0 specifies that there are no escape-coded samples in the current coding unit. When the palette_escape_val_present_flag is not present, its value is inferred to be equal to 1.

[0168] The variable MaxPaletteIndex specifies the maximum possible value of the palette index for the current coding unit. The value of MaxPaletteIndex is set to be equal to CurrentPaletteSize[startComp] - 1 + palette_escape_val_present_flag.

[0169] palette_idx_idc is an indication of the index into the palette table CurrentPaletteEntries. The value of palette_idx_idc must be in the range from 0 to MaxPaletteIndex (inclusive of the endpoints) for the first index in the block, and in the range from 0 to (MaxPaletteIndex - 1) (inclusive of the endpoints) for the remaining indices in the block.

[0170] When palette_idx_idc is not present, it is inferred to be equal to 0.

[0171] A palette_transpose_flag equal to 1 specifies that a vertical traversal scan is applied to scan the indices of the samples in the current coding unit. A palette_transpose_flag equal to 0 specifies that a horizontal traversal scan is applied to scan the indices of the samples in the current coding unit. When the palette_transpose_flag is not present, its value is inferred to be equal to 0.

[0172] The array TraverseScanOrder specifies the scan order array for palette coding / decoding. If palette_transpose_flag equals 0, then HorTravScanOrder, the horizontal scan order, is assigned to TraverseScanOrder, and if palette_transpose_flag equals 1, then VerTravScanOrder, the vertical scan order, is assigned to TraverseScanOrder.

[0173] run_copy_flag being equal to 1 specifies that the palette run type is the same run type as at the previous scan position, and if copy_above_palette_indices_flag equals 0, then the palette run index is the same as the index at that previous position. Otherwise, run_copy_flag equals 0.

[0174] copy_above_palette_indices_flag being equal to 1 specifies that: if horizontal traversal scan is used, then the palette index is equal to the palette index at the same position in the row above; if vertical traversal scan is used, then the palette index is equal to the palette index at the same position in the column to the left. copy_above_palette_indices_flag being equal to 0 specifies that the indication of the palette index of the sample is coded / decoded into the bitstream representation or inferred.

[0175] The variable CopyAboveIndicesFlag[xC][yC] being equal to 1 specifies that the palette index is copied from the palette index in the row above (horizontal scan) or the column to the left (vertical scan). CopyAboveIndicesFlag[xC][yC] being equal to 0 specifies that the palette index is explicitly coded / decoded into the bitstream or inferred. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luma sample of the picture.

[0176] The variable PaletteIndexMap[xC][yC] specifies the palette index, which is an index into the array represented by CurrentPaletteEntries. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luma sample of the picture. The value of PaletteIndexMap[xC][yC] must be in the range from 0 to MaxPaletteIndex, inclusive of the endpoints.

[0177] The variable adjustedRefPaletteIndex is derived as follows:

[0178]

[0179]

[0180] When CopyAboveIndicesFlag[xC][yC] is equal to 0, the following derives the variable CurrPaletteIndex:

[0181] if(CurrPaletteIndex >= adjustedRefPaletteIndex)

[0182] CurrPaletteIndex++ (7-158)

[0183] The palette_escape_val specifies the quantization escape coded sample value of a component.

[0184] The variable PaletteEscapeVal[cIdx][xC][yC] specifies the escape value of a sample for which PaletteIndexMap[xC][yC] is equal to MaxPaletteIndex and palette_escape_val_present_flag is equal to 1. The array index cIdx specifies the color component. The array indices xC, yC specify the position (xC, yC) of the sample relative to the top-left luma sample of the picture.

[0185] The requirement for bitstream conformance is that for cIdx equal to 0, PaletteEscapeVal[cIdx][xC][yC] must be in the range from 0 to (1<<(BitDepthY+1))-1 (including the endpoints); for cIdx not equal to 0, PaletteEscapeVal[cIdx][xC][yC] must be in the range from 0 to (1<<(BitDepthC+1))-1 (including the endpoints).

[0186] 2.3 Local dual-tree in VVC

[0187] In typical hardware video encoders and decoders, due to the sample processing data dependencies between adjacent intra-blocks within a frame, when a picture has more small intra-blocks, the processing throughput will decrease. The generation of intra-block predictors requires reconstructed samples from the top and left boundaries of adjacent blocks. Therefore, intra prediction must be processed block by block sequentially.

[0188] In HEVC, the smallest intra-CU is 8x8 luma samples. The luma component of the smallest intra-CU can be further divided into four 4x4 luma intra prediction units (PUs), but the chroma component of the smallest intra-CU cannot be further divided. Therefore, the worst-case hardware processing throughput occurs when processing 4x4 chroma intra blocks or 4x4 luma intra blocks.

[0189] In VTM5.0, in a single codec tree, since chroma segmentation always follows luma and the smallest intra-CU is 4x4 luma samples, the smallest chroma intra-CB is 2x2. Therefore, in VTM5.0, the smallest chroma intra-CB in a single codec tree is 2x2. The worst-case hardware processing throughput for VVC decoding is a quarter of that throughput for HEVC decoding. In addition, after adopting tools including cross-component linear model (CCLM), 4-tap interpolation filter, position-dependent intra prediction combination (PDPC), and combined inter-intra prediction (CIIP), the reconstruction process of chroma intra-CBs becomes much more complex than that process in HEVC. It is difficult to achieve high processing throughput in a hardware decoder. In this section, a method to improve the worst-case hardware processing throughput is proposed.

[0190] The goal of this method is to improve the worst-case hardware processing throughput by restricting the segmentation of chroma intra-CBs and not allowing chroma intra-CBs smaller than 16 chroma samples.

[0191] In a single codec tree, a SCIPU is defined as a codec tree node whose chroma block size is greater than or equal to TH chroma samples and has at least one sub-luma block smaller than 4TH luma samples, where TH is set to 16 in this document. It is required that all CBs in each SCIPU are inter or all CBs are non-inter, i.e., intra or IBC. For non-inter SCIPUs, it is further required that the chroma of the non-inter SCIPU must not be further divided, and further division of the luma of the SCIPU is allowed. In this way, the smallest chroma intra-CB size is 16 chroma samples, and 2x2, 2x4, and 4x2 chroma CBs are removed. In addition, chroma scaling is not applied to non-inter SCIPUs. In addition, when further dividing luma blocks and not dividing chroma blocks, a local double-tree codec structure is constructed.

[0192] Figure 5A and Figure 5B shows two SCIPU examples. In Figure 5A , a chroma CB with 8x4 chroma samples and three luma CBs (4x8, 8x8, 4x8 luma CBs) form a SCIPU because the ternary tree (TT) divided from these 8x4 chroma samples will produce chroma CBs smaller than 16 chroma samples. InFigure 5B Among them, a chrominance CB with 4x4 chrominance samples (to the left of the 8x4 chrominance samples) and three luma CBs (8x4, 4x4, 4x4 luma CBs) form an SCIPU, and another chrominance CB with 4x4 samples (to the right of the 8x4 chrominance samples) and two luma CBs (8x4, 8x4 luma CBs) form an SCIPU, because the binary tree (BT) divided by the 4x4 chrominance samples will produce a chrominance CB with less than 16 chrominance samples.

[0193] In the proposed method, if the current slice is an I slice or after a further division the current SCIPU has a 4x4 luma split located within it (because inter 4x4 is not allowed in VVC), then the type of the SCIPU is inferred as non-inter; otherwise, the type of the SCIPU (inter or non-inter) is indicated by a signaling flag before parsing the CUs in the SCIPU.

[0194] By applying the above method, the worst-case hardware processing throughput occurs when processing 4x4, 2x8, or 8x2 chrominance blocks instead of 2x2 chrominance blocks. This worst-case hardware processing throughput is the same as that in HEVC and is 4 times that in VTM5.0.

[0195] 2.4 Transform Skip (TS)

[0196] Similar to HEVC, the transform skip mode can be adopted to encode the residuals of blocks. To avoid redundant syntax coding, the transform skip flag is not signaled when the MTS_CU_flag at the CU level is not equal to zero. The block size limit for transform skip is the same as the block size limit for MTS in JEM4, which means that transform skip is applicable for a CU when both the block width and height are equal to or less than 32. Note that when LFNST or MIP is not started for the current CU, the implicit MTS transform is set to DCT2. Moreover, when MTS is enabled for inter-coded blocks, this implicit MTS can still be enabled.

[0197] In addition, for transform skip blocks, the minimum allowable quantization parameter (QP) is defined as 6*(internalBitDepth–inputBitDepth)+4.

[0198] 2.5 Alternative Luma Half-Pixel Interpolation Filter

[0199] In JVET-N0309, an alternative half-pixel interpolation filter was proposed.

[0200] The switching of the half - pixel interpolation filter is completed according to the motion vector precision. In addition to the existing quarter - pixel, full - pixel, and 4 - pixel AMVR modes, a new half - pixel precision AMVR mode is introduced. Only in the case of half - pixel motion vector precision, an alternative half - pixel luminance interpolation filter can be selected.

[0201] For non - affine non - merge inter - frame - coded CUs using half - pixel motion vector precision (i.e., half - pixel AMVR mode), the switching between the HEVC / VVC half - pixel luminance interpolation filter and one or more alternative half - pixel interpolations is made based on the new syntax element hpelIfIdx. For the half - pixel AMVR mode, the syntax element hpelIfIdx is not signaled. For the skip / merge mode using spatial merging candidates, the value of the syntax element hpelIfIdx is inherited from adjacent blocks.

[0202] 2.6 Adaptive Color Transform (ACT)

[0203] Figure 6 The decoding flow chart when applying ACT is shown. As Figure 6 shown, the color space conversion is performed in the residual domain. Specifically, an additional decoding module called inverse ACT is introduced after the inverse transform to convert the residual from the YCgCo domain back to the original domain.

[0204] In VVC, unless the maximum transform size is less than the width or height of a coding unit (CU), a CU leaf node is also used as the unit for transform processing. Therefore, in the proposed implementation, an ACT flag is signaled for a CU to select the color space for encoding its residual. In addition, following the HEVC ACT design, for inter - frame and IBC CUs, ACT is enabled only when there is at least one non - zero coefficient in the CU. For intra CUs, ACT is enabled only when the intra - prediction mode for the chrominance component is the same as that for the luminance component (i.e., DM mode).

[0205] The core transform for color space conversion is the same as that for HEVC. Specifically, the following forward and inverse YCgCo color transform matrices are applied, as described below.

[0206]

[0207] In addition, to compensate for the dynamic range change of the residual signal before and after the color transform, a QP adjustment of (-5, -5, -3) is applied to the transform residual.

[0208] On the other hand, forward and inverse color transforms are required to access the residuals of all three components. Correspondingly, in the proposed implementation, ACT is disabled in the following two cases where not all residuals of the three components are available.

[0209] 1. Separate tree splitting: When applying a separate tree, the luma samples and chroma samples within a CTU are split according to different structures. This results in CUs in the luma tree containing only the luma component and CUs in the chroma tree containing only two chroma components.

[0210] Intra-subdivision prediction (ISP): ISP sub-division is applied only to luma, while the chroma signal is coded without division. In the current ISP design, except for the last ISP sub-division, other sub-divisions contain only the luma component.

[0211] 3. Technical problems solved by the technical solutions and embodiments described herein

[0212] 1. The current escape symbol binarization is not of fixed length, which is suitable for sources with non-uniform distributions.

[0213] 2. The current palette codec design performs an index adjustment process to remove possible redundancies, which may lead to parsing redundancies, for example, when incorrectly deriving the escape value index.

[0214] 3. The reference index used to derive the current index may require encoder constraints, which are not considered in the current design and are undesirable for codec design.

[0215] 4. When local dual-tree is enabled, the palette indices of the previous block and the current block may have different numbers of color components. It is not clear how to handle such a situation.

[0216] 5. Local dual-tree and PLT may not be applicable simultaneously because some palette entries may be repeated when coding / decoding from a single-tree region to a dual-tree region. Figure 7 An example is shown.

[0217] 6. The chroma QP table for the joint_cbcr mode may be restricted.

[0218] 7. Under certain conditions, escape samples may be redundant.

[0219] 8. It may not be possible to process the line-based CG mode with high throughput.

[0220] 4. Enumeration of embodiments and solutions

[0221] The following enumerations should be regarded as examples for explaining the general concept. These items should not be interpreted narrowly. In addition, these items can be combined in any way.

[0222] The following examples can be applied to the palette scheme in VVC and all other palette-related schemes.

[0223] When x is a positive integer, define Modulo(x,M) as (x % M); otherwise, define it as M - ((-x) % M).

[0224] In the following, a block decoded in lossless mode can mean that the block is decoded when tranquant_bypass_flag is equal to 1; or the block is decoded when QP is not greater than a given threshold and transform_skip_flag is equal to 1.

[0225] The following examples can be applied to the palette scheme in VVC and all other palette-related schemes.

[0226] 1. Fixed-length coding can be applied to code escape symbols.

[0227] a. In one example, fixed-length binary signaling can be used to signal escape symbols.

[0228] b. In one example, escape symbols can be signaled in fixed-length binary using N bits.

[0229] c. In one example, the code length for signaling escape symbols (e.g., N mentioned in bullet 1.b) can depend on the internal bit depth.

[0230] i. Alternatively, the code length for signaling escape symbols can depend on the input bit depth.

[0231] ii. Alternatively, the code length for signaling escape symbols can depend on the difference between the internal bit depth and the input bit depth.

[0232] iii. In one example, set N to be equal to the input / internal bit depth.

[0233] d. In one example, the code length for signaling escape symbols (e.g., N mentioned in bullet 1.b) can depend on the quantization parameter, i.e., Qp.

[0234] i. In one example, the code length for signaling escape symbols can be a function of the quantization parameter, e.g., represented by f(Qp).

[0235] 1. In one example, the function can be defined as (internal bitdepth–g(Qp))

[0236] 2. In one example, N can be set to (internal bitdepth–max(16,(Qp-4) / 6)).

[0237] 3. In one example, N can be set to (internal bitdepth–max(QpPrimeTsMin,(Qp-4) / 6)), where qP is the decoded quantization parameter and QpPrimeTsMin is the minimum allowed quantization parameter for the transform skip mode.

[0238] 4. Alternatively, the code length N can be set to max(A,internalbitDepth-(Max(QpPrimeTsMin,Qp)–4) / 6), where A is a non-negative integer value such as 0 or 1.

[0239] e. In the above examples, N can be greater than or equal to 0.

[0240] 2. It is proposed to prohibit the use of escape symbols in a video unit (e.g., CU).

[0241] a. Alternatively, in addition, signaling of the indication of the existence of escape symbols is skipped.

[0242] b. In one example, whether to enable / disable the use of escape symbols can depend on the quantization parameter and / or bit depth.

[0243] i. In one example, if (internal bitDepth-(Max(QpPrimeTsMin,Qp)–4) / 6) is not greater than 0, then the use of escape symbols can be disabled.

[0244] 3. Variable length coding and decoding excluding 3rd order EG can be applied to encode and decode escape symbols.

[0245] a. In one example, the binarization of escape symbols can be a truncated binary code (TB) using the input parameter K.

[0246] b. In one example, the binarization of escape symbols can be Kth order EG, where K is not equal to 3.

[0247] i. In one example, the binarization of escape symbols can be 0th order EG.

[0248] 1. Alternatively, in one example, the binarization of escape symbols can be 1st order EG.

[0249] 2. In one example, the binarization of the escape symbol can be 2nd order EG.

[0250] c. In one example, K can be an integer value and can depend on:

[0251] i. Messages signaled in SPS / VPS / PPS / picture header / strip header / slice group header / LCU row / LCU group / tile.

[0252] ii. Internal bit depth

[0253] iii. Input bit depth

[0254] iv. The difference between the internal bit depth and the input depth

[0255] v. The block dimension of the current block

[0256] vi. The current quantization parameter of the current block

[0257] vii. Indication of the color format (such as 4:2:0, 4:4:4, RGB or YUV)

[0258] viii. Coding / decoding structure (such as single tree or double tree)

[0259] ix. Color components (such as luminance component and / or chrominance component)

[0260] 4. Multiple binarization methods for encoding / decoding escape symbols can be applied to video units (e.g., sequence / picture / strip / slice / tile / sub-picture / CTU row / CTU / CTB / CB / CU / sub-region within a picture) and / or for one or more escape symbol values.

[0261] a. In one example, for a video unit and / or for one or more escape symbol values, how to select one of the multiple binarization methods can be signaled.

[0262] b. In one example, for a video unit and / or for one or more escape symbol values, how to select one of the multiple binarization methods can be derived.

[0263] c. In one example, for a video unit and / or for one or more escape symbol values, two or more binarization methods can be applied.

[0264] i. In one example, an index or flag can be encoded / decoded to identify the selected binarization method.

[0265] In the following bullets, p can represent the symbolic value of a color component, bd can represent the bit depth (e.g., internal bit depth or input bit depth), ibd can represent the input bit depth, and Qp can represent the quantization parameter for transform skip blocks or transform blocks. Additionally, the QP for the luminance component and the chrominance component can be different or the same. The bit depth can be associated with a given color component.

[0266] 5. How the quantization and / or inverse quantization process is applied can depend on whether the block is coded in palette mode.

[0267] a. In one example, the quantization and / or inverse quantization process for escape symbols can be different from those for normal intra / inter coded blocks to which quantization is applied.

[0268] 6. The quantization and / or inverse quantization process for escape symbols can use bit shifting.

[0269] a. In one example, a right bit shift can be used to quantize the escape symbols.

[0270] i. In one example, the escape symbol can be signaled as f(p,Qp), where p is the input symbol value (e.g., input luminance / chrominance sample value) and Qp is the derived quantization parameter for the corresponding color component.

[0271] 1. In one example, the function f can be defined as p>>g(Qp).

[0272] 2. In one example, the function f can be defined as (p+(1<<(g(QP)-1)))>>g(Qp).

[0273] 3. In one example, the function f can be defined as (0,(1<<bd)-1,(p+(1<<(g(QP)-1)))>>g(Qp)).

[0274] ii. In one example, the escape symbol can be signaled as h(p).

[0275] 1. In one example, the function h can be defined as p>>N.

[0276] 2. In one example, the function h can be defined as (p+(1<<(N-1)))>>N.

[0277] 3. In one example, when cu_transquant_bypass_flag equals 1, N can be set to 0.

[0278] 4. In one example, when cu_transquant_bypass_flag equals 1, N can be set to equal (bd - ibd), where bd is the internal bit depth and ibd is the input bit depth.

[0279] 5. In one example, the function h can be defined as clip(0, (1 << (bd - N) - 1, p >> N), where bd is the internal bit depth of the current color component.

[0280] 6. In one example, the function h can be defined as clip(0, (1 << (bd - N) - 1, (p + (1 << (N - 1))) >> N), where bd is the internal bit depth of the current color component.

[0281] 7. In the above examples, N can be in the range of [0, (bd – 1)].

[0282] b. In one example, left bit shifting can be used to inverse quantize the escape symbol.

[0283] i. In one example, the escape symbol can be inverse quantized to f(p, Qp), where p is the decoded escape symbol and Qp is the derived quantization parameter for the corresponding color component.

[0284] 1. In one example, f can be defined as p << g(Qp)

[0285] 2. In one example, f can be defined as (p << g(Qp)) + (1 << (g(Qp) - 1)).

[0286] ii. In one example, the escape symbol can be reconstructed as f(p, Qp), where p is the decoded escape symbol.

[0287] 1. In one example, f can be defined as clip(0, (1 << bd) - 1, p << g(Qp))

[0288] 2. In one example, f can be defined as clip(0, (1 << bd) - 1, (p << g(Qp)) + (1 << (g(Qp) - 1))).

[0289] iii. In one example, the escape symbol can be reconstructed as h(p).

[0290] 1. In one example, the function h can be defined as p << N.

[0291] 2. In one example, the function h can be defined as (p << N) + (1 << (N - 1))

[0292] 3. In one example, when cu_transquant_bypass_flag is equal to 1, N can be set to 0.

[0293] 4. In one example, when cu_transquant_bypass_flag is equal to 1, N can be set to be equal to (bd - ibd), where bd is the internal bit depth and ibd is the input bit depth.

[0294] 5. In one example, N can be set to (max(QpPrimeTsMin, qP) - 4) / 6, where qP is the decoded quantization parameter, and QpPrimeTsMin is the minimum allowed quantization parameter for the transform skip mode.

[0295] a) In the above example, if both the luminance and chrominance have the transform skip mode, then different minimum allowed quantization parameters for the transform skip mode can be applied to different color components.

[0296] 6. Alternatively, for the above example, N can be further clipped, for example, min(bd - 1, N).

[0297] 7. In the above example, N can be in the range of [0, (bd – 1)].

[0298] 7. When applying left shift as the inverse quantization, the reconstruction offset of the escape symbol p can depend on the bit depth information.

[0299] a. In one example, it can depend on the difference between the internal bit depth and the input bit depth, i.e., deltaBD = internal bidepth – input bitdepth.

[0300] b. When K is less than or equal to deltaBD, the reconstructed value can be p << K.

[0301] c. When K is greater than deltaBD, the reconstructed value can be (p << K)+(1 << (K - 1)).

[0302] d. When K is less than or equal to T0 (e.g., T0 = 2), the reconstructed value can be p << K.

[0303] e. When K is greater than T1 (e.g., T1 = 2), the reconstructed value can be (p << K)+(1 << (K - 1))

[0304] f. In one example, T0 and T1 in items d and e can be signaled in the bitstream (e.g., at the sequence / picture / strip / slice / tile / subpicture level).

[0305] g. In one example, the reconstructed value can be (p << K) + ((1 << (K - 1)) >> deltaBD << deltaBD).

[0306] h. In one example, the reconstructed value can be ((p << (K + 1)) + (1 << K)) >> (deltaBD + 1) << deltaBD.

[0307] i. In one example, deltaBD can be signaled in the bitstream (e.g., at the sequence / picture / strip / slice / tile / sub - picture level).

[0308] j. In one example, which reconstructed value to use (e.g., bullet points b to e) can depend on the quantization parameter of the current block.

[0309] k. In one example, which reconstructed value to use (e.g., bullet points b to e) can depend on the value of deltaBD.

[0310] l. In one example, K can be set to g(Qp).

[0311] 8. In the above examples, the following can apply:

[0312] a. In one example, escape symbols can be context - decoded.

[0313] b. In one example, escape symbols can be bypass - decoded.

[0314] c. In one example, g(Qp) can be defined as (Qp - 4) / 6 or QP / 8.

[0315] i. Alternatively, g(Qp) can be defined as Qp / 6 or QP / 8.

[0316] ii. Alternatively, g(Qp) can be defined as max(16, Qp / 6)).

[0317] iii. Alternatively, g(Qp) can be defined as max(16, (Qp - 4) / 6).

[0318] iv. Alternatively, g(Qp) can be defined as max((bd - ibd)*6 + 4, (Qp - 4) / 6).

[0319] v. Alternatively, g(Qp) can be defined as max(M, (Qp - 4) / 6).

[0320] 1. In one example, M can be signaled to the decoder.

[0321] vi. Alternatively, g(Qp) can be defined as max((M, Qp) - 4) / 6.

[0322] 1. In one example, M can be indicated in the SPS.

[0323] 2. In one example, the same or different Ms can be applied to the luminance and chrominance components.

[0324] 3. In one example, M can be equal to (bd - ibd)*6 + 4.

[0325] vii. Alternatively, g(Qp) can be defined as Qp / 6 or QP / 8.

[0326] viii. Alternatively, g(Qp) can be defined as (max(16, Qp) / 6).

[0327] ix. Alternatively, g(Qp) can be defined as (max(16, Qp) - 4) / 6.

[0328] d. In the above examples, the value of g(Qp) can be in the range of [0, (bd – 1)].

[0329] e. In one example, the max function max(a, i) can be defined as (i <= a? a : i).

[0330] i. Alternatively, in one example, the max function max(a, i) can be defined as (i < a? a : i).

[0331] f. In one example, N can be an integer (e.g., 8 or 10) and can depend on:

[0332] i. Messages signaled in the SPS / VPS / PPS / picture header / strip header / slice group header / LCU row / LCU group / tile.

[0333] ii. The internal bit depth

[0334] iii. The input bit depth

[0335] iv. The difference between the internal bit depth and the input depth

[0336] v. The block dimension of the current block

[0337] vi. The current quantization parameter of the current block

[0338] vii. Indication of the color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0339] viii. The coding structure (such as single tree or dual tree)

[0340] ix. Color components (such as luminance component and / or chrominance component)

[0341] x. Slice / tile type and / or picture type

[0342] g. In one example, N signaling can be notified to the decoder.

[0343] 9. The Qp for escape values can be clipped.

[0344] a. In one example, the lowest Qp applied to the escape value can be equal to min_qp_prime_ts_minus4.

[0345] b. In one example, the lowest Qp applied to the escape value can be related to min_qp_prime_ts_

[0346] minus4.

[0347] i. In one example, the lowest Qp applied to the escape value can be equal to min_qp_prime_ts_minus4 + 4.

[0348] c. In one example, the lowest Qp for each color component can be indicated in the SPS / PPS / VPD / DPS / slice / tile header.

[0349] d. In one example, the lowest Qp applied to the escape value can be (bd - ibd)*6 + 4, where bd is the internal bit depth and ibd represents the input bit depth for a certain color component.

[0350] e. In one example, the above examples can be applied to a certain color component.

[0351] 10. In the above examples, the chrominance Qp for escape values can use the Qp before / after mapping.

[0352] 11. It is proposed that the reference index is not used when deriving the current palette index in the palette mode.

[0353] a. In one example, the palette index can be directly signaled without excluding the possibility of the reference index (e.g., adjustedRefPaletteIndex).

[0354] i. Alternatively, in one example, the encoder can be restricted to enabling a reference index that is always different from the current index. In such a case, the palette index can be signaled by excluding the possibility of the reference index.

[0355] b. In one example, the binarization of the palette index can be Truncated Binary (TB), where the maximum palette index is used as the binarization input parameter.

[0356] c. In one example, the binarization of the palette index can be of a fixed length.

[0357] d. In one example, the binarization of the palette index can be K - order EG.

[0358] i. In one example, K can be an integer value (e.g., 1, 2, or 3) and can depend on:

[0359] 1. Messages signaled in the SPS / VPS / PPS / picture header / slice header / tile group header / LCU row / LCU group / tile.

[0360] 2. The internal bit depth

[0361] 3. The input bit depth

[0362] 4. The difference between the internal bit depth and the input depth

[0363] 5. The block dimension of the current block

[0364] 6. The current quantization parameter of the current block

[0365] 7. An indication of the color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0366] 8. The coding structure (such as single - tree or dual - tree)

[0367] 9. The color components (such as the luminance component and / or the chrominance component)

[0368] e. In one example, the above examples can be applied only when the current block has at least one escape sample.

[0369] 12. The current palette index can be signaled independently of the previous palette index.

[0370] a. In one example, whether and / or how to use the previous palette index can depend on whether there are escape samples in the current block.

[0371] 13. It can be not allowed to derive the index of non - escape symbols from the index of escape symbols.

[0372] a. In one example, when applying an escape symbol and the palette index is not equal to the index of the escape symbol, it can be not allowed to decode the symbol into an escape symbol.

[0373] 14. It may not be allowed to derive the index of an escape symbol from the index of a non-escape symbol.

[0374] a. In one example, when an escape symbol is applied and the palette index is equal to the index of the escape symbol, it may not be allowed to decode the symbol into a non-escape symbol.

[0375] 15. An upper limit may be added to the derived palette index by the current palette table size.

[0376] a. In one example, when the palette index is greater than MaxPaletteIndex, it may be modified to be equal to MaxPaletteIndex.

[0377] 16. An upper limit may be added to the derived palette index by the current palette table size excluding the index of the escape symbol.

[0378] a. In one example, when the escape symbol is not applied and the palette index is greater than MaxPaletteIndex, it may be modified to be equal to MaxPaletteIndex.

[0379] b. In one example, when the escape symbol is applied and the palette index is greater than (MaxPaletteIndex – 1), it may be modified to be equal to (MaxPaletteIndex – 1).

[0380] 17. It may not be allowed to modify the index indicating the escape symbol.

[0381] a. In one example, when there is an escape symbol in the current block, the index equal to MaxPaletteIndex may always indicate the escape symbol.

[0382] b. In one example, an index not equal to MaxPaletteIndex may not be decoded as the index indicating the escape symbol.

[0383] 18. It is proposed to encode and decode the difference between the reference index and the current index.

[0384] a. In one example, it may not be allowed to encode and decode the difference equal to 0.

[0385] b. Alternatively, for the first index in the palette encoding block, the index may be directly encoded and decoded.

[0386] 19. It is proposed to encode and decode the modulus of the difference between the reference index (represented as R) and the current index (represented as C).

[0387] a. In one example, I = Modulo(C - R, MaxPaletteIndex) can be encoded.

[0388] i. In one example, the index can be reconstructed as Modulo(I + R, MaxPaletteIndex)

[0389] ii. In one example, Modulo(C - R, MaxPaletteIndex) equal to 0 may not be allowed in the bitstream.

[0390] iii. In one example, a truncated binary code with cMax = MaxPaletteIndex can be used to encode and decode this value.

[0391] iv. Alternatively, for the first index in the palette encoding / decoding block, the index can be directly encoded and decoded.

[0392] b. In one example, I = Modulo(C - R, MaxPaletteIndex) - 1 can be encoded and decoded.

[0393] i. In one example, the index can be reconstructed as Modulo(I + 1 + R, MaxPaletteIndex)

[0394] ii. In one example, Modulo(C - R, MaxPaletteIndex) - 1 less than 0 may not be allowed in the bitstream.

[0395] iii. In one example, a truncated binary code with cMax = (MaxPaletteIndex - 1) can be used to encode and decode the value I.

[0396] iv. Alternatively, for the first index in the palette encoding / decoding block, Modulo(C - R, MaxPaletteIndex) can be encoded and decoded.

[0397] v. Alternatively, for the first index in the palette encoding / decoding block, the index can be directly encoded and decoded.

[0398] 20. When starting to decode the palette block, the reference index R can be set equal to -1.

[0399] a. Alternatively, the reference index R can be set equal to 0.

[0400] 21. Mutually enabling the palette mode and the local dual tree is proposed.

[0401] a. In one example, when palette mode is enabled, local dual - tree may not be allowed.

[0402] i. Alternatively, in one example, when local dual - tree is enabled, palette mode may not be allowed.

[0403] b. In one example, local dual - tree is not enabled for a specific color format (e.g., 4:4:4).

[0404] c. In one example, when the codec tree is MODE_TYPE_INTRA, palette mode may not be allowed.

[0405] d. A reset palette predictor based on the use of local dual - tree is proposed.

[0406] i. In one example, the palette predictor can be reset when switching from a single - tree to a local dual - tree.

[0407] ii. In one example, the palette predictor can be reset when switching from a local dual - tree to a single - tree.

[0408] iii. Alternatively, furthermore, whether to signal the use of entries in the palette predictor (e.g., palette_predictor_run) can depend on the tree type.

[0409] 1. In one example, when encountering a switch between local dual - tree and single - tree, signaling the use of entries in the palette predictor (e.g., palette_predictor_run) is omitted.

[0410] 22. Removing duplicate palette entries in the palette prediction table when applying local dual - tree is proposed.

[0411] a. In one example, the palette prediction table can be reset when applying local dual - tree.

[0412] i. Alternatively, in one example, when applying local dual - tree, the decoder can check all palette entries in the prediction table and remove duplicate palette entries.

[0413] ii. Alternatively, in one example, when applying local dual - tree, the decoder can check some of the palette entries in the prediction table and remove duplicate palette entries.

[0414] iii. In one example, full pruning or partial pruning can be applied when checking palette entries.

[0415] 1. In one example, a selected set of entries can be checked (e.g., the set includes all or some of the palette entries in the palette predictor).

[0416] a) In one example, full or partial pruning can be applied to the selected entries.

[0417] 2. In one example, full pruning can mean comparing an entry with all the entries that can be added.

[0418] 3. In one example, partial pruning can mean comparing an entry with some of the entries that can be added.

[0419] iv. In one example, whether two palette entries are the same can be based on whether their luminance component values are the same.

[0420] 1. Alternatively, in one example, whether two palette entries are the same can be based on whether their chrominance component values are the same.

[0421] 2. Alternatively, in one example, whether two palette entries are the same can be based on whether both their luminance and chrominance component values are the same.

[0422] v. In one example, the above method can be applied to luminance blocks only when the local double-tree starts processing the luminance component.

[0423] 1. Alternatively, in one example, the above method can be applied to chrominance blocks only when the local double-tree starts processing the chrominance component.

[0424] vi. Alternatively, in one example, the encoder can add a constraint to consider two different palette entries, where the two entries are different when their three components are different.

[0425] 23. When the current palette entry has a different number of color components from the entries in the palette prediction table, the use of the palette prediction table can be disallowed.

[0426] a. In one example, when the current palette entry has a different number of color components from the prediction, the reuse flag of all the entries in the palette prediction table can be marked as true, but it can not be used for the current block.

[0427] b. In one example, when the current palette entry has a different number of color components from the prediction, the reuse flag of all the entries in the palette prediction table can be marked as false.

[0428] 24. When the prediction table has different color components from the current palette table, the use of the palette prediction table can be disallowed.

[0429] a. In one example, when the prediction table has different color components from the current palette table, the reuse flag of all entries in the palette prediction table can be marked as true, but it may not be used for the current block.

[0430] b. In one example, when the prediction table has different color components from the current palette table, the reuse flag of all entries in the palette prediction table can be marked as false.

[0431] 25. Predictive coding can be performed on escape symbols, for example, based on previously coded escape symbols. a. In one example, an escape symbol in one component can be predicted by the coded values in the same color component.

[0432] i. In one example, the escape symbol can use the previously coded escape symbol in the same component as a predictor and can signal the residual between them.

[0433] ii. Alternatively, the escape symbol can use the K-th previously coded escape symbol in the same component as a predictor and can signal the residual between them.

[0434] iii. Alternatively, the escape symbol can be predicted by multiple (e.g., K) coded escape symbols in the same component.

[0435] 1. In one example, K can be an integer value (e.g., 1, 2, or 3) and can depend on:

[0436] a) Messages signaled in the SPS / VPS / PPS / picture header / strip header / slice group header / LCU row / LCU group / tile.

[0437] b) Internal bit depth

[0438] c) Input bit depth

[0439] d) The difference between the internal bit depth and the input depth

[0440] e) The block dimensions of the current block

[0441] f) The current quantization parameter of the current block

[0442] g) Indication of the color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0443] h) Coding structure (such as single tree or double tree)

[0444] i) Color components (such as the luminance component and / or chrominance components)

[0445] b. In one example, the escape symbol in one component can be predicted by the coding / decoding value in another component.

[0446] c. In one example, a pixel can have multiple color components, and if the pixel is treated as an escape symbol, then the value of one component can be predicted by the values of the samples of the other components.

[0447] i. In one example, the U component of the escape symbol can be predicted by the V component of the symbol.

[0448] d. In one example, the above method can be applied only to a certain color component (e.g., the luminance component or the chrominance component) or under certain conditions (e.g., based on coding information).

[0449] 26. The signaling of the syntax elements related to the palette can depend on the maximum size of the palette and / or the block dimension and / or the use of the lossless mode and / or the quantization parameter (QP).

[0450] a. In one example, for a lossless code block and / or QP not greater than a threshold and / or applying transform skip, the palette size of the block is inferred to be equal to the block dimension.

[0451] i. Alternatively, for a lossless code block and / or QP not greater than a threshold, the palette size of the block is inferred to be equal to min(block dimension, maximum palette size).

[0452] b. Whether to signal the use of the escape samples in the block can depend on the block dimension and / or the use of the lossless coding / decoding mode (e.g., whether QP is equal to a given value (e.g., 4); and / or transform_skip_flag is equal to 1; or whether transquant_bypass_flag is equal to true) and / or Qp.

[0453] i. Alternatively, in addition, whether to signal the use of the escape samples can depend on the relationship between the block dimension of the current block and the current palette size.

[0454] 1. In one example, whether to signal it can depend on whether the block dimension is equal to the current palette size.

[0455] a) Alternatively, in addition, if the block dimension is equal to the current palette size, then it is not signaled and is inferred to be false.

[0456] 2. Alternatively, whether to signal it can depend on whether the block dimension is less than the current palette size.

[0457] a) Alternatively, in addition, if the block dimension is not less than the current palette size, then it is not signaled and is inferred to be false.

[0458] ii. Alternatively, moreover, whether signaling the use of escape samples can depend on the relationship between the block dimension, the maximum size of the palette, and / or the lossless mode.

[0459] 1. In one example, if a block is coded / decoded in lossless mode and the block dimension is less than the maximum size of the palette, then signaling of the use of escape samples can be omitted and inferred as false.

[0460] 2. In one example, if a block is coded with a QP not greater than a threshold and the block dimension is less than the maximum size of the palette, then signaling of the use of escape samples can be omitted and inferred as false.

[0461] iii. The indication of the use of escape samples (e.g., palette_escape_val_present_flag) can be inferred under certain conditions.

[0462] 1. In one example, when the current block size is less than or equal to the maximum allowed palette size (e.g., palette_max_size), the indication of the use of escape samples can be inferred as false.

[0463] a) Alternatively, in one example, when the current block size is greater than the maximum allowed palette size, the indication of the use of escape samples can be signaled.

[0464] b) Alternatively, in one example, when the current block size is greater than the maximum allowed palette size, the indication of the use of escape samples can be inferred as false.

[0465] 2. In one example, the above method can be applied under lossless coding / decoding conditions.

[0466] 3. In one example, the above method can be applied to a CU that is losslessly coded / decoded.

[0467] 4. In one example, when the current block size is less than or equal to the palette size of the current block, the indication of the use of escape samples can be inferred as false.

[0468] 5. In one example, when inferring the use flag of escape samples, the corresponding syntax element can be skipped in the bitstream, e.g., palette_escape_val_present_flag.

[0469] 27. The context for run - length coding in palette mode can depend on the palette index used to index the palette entries.

[0470] a. In one example, the palette index after the index adjustment process at the decoder (mentioned in section 2.1.3) can be used to derive the context for the prefix of the length element (e.g., palette_run_prefix).

[0471] b. Alternatively, the I defined in item 13 can be used instead of the palette index to derive the context for the prefix of the length element (e.g., palette_run_prefix).

[0472] 28. It is proposed to align the positions of the left and / or above neighboring blocks used in the derivation process of the quantization parameter predictor with the positions of the left and / or above neighboring blocks used in the mode / MV (e.g., MPM) derivation.

[0473] a. Align the positions of the left and / or above neighboring blocks used in the derivation process of the quantization parameter predictor with those used in the merge / AMVP candidate list derivation process.

[0474] b. In one example, the positions of the left and / or above neighboring blocks used in the derivation process of the quantization parameter predictor can be Figure 8 the left / above neighboring blocks shown in

[0475] 29. The block-level QP difference can be sent independently of whether there are escape samples in the current block.

[0476] a. In one example, whether and / or how to send the block-level QP difference can be subject to the blocks encoded and decoded in other modes than the palette.

[0477] b. In one example, the block-level QP difference can always not be sent for the palette blocks.

[0478] c. In one example, when the block width is greater than the threshold, the block-level QP difference can be sent for the palette blocks.

[0479] d. In one example, when the block height is greater than the threshold, the block-level QP difference can be sent for the palette blocks.

[0480] e. In one example, when the block size is greater than the threshold, the block-level QP difference can be sent for the palette blocks.

[0481] f. In one example, the above examples can only apply to the luma blocks or chroma blocks.

[0482] 30. One or more (e.g., cbf_luma, cbf_cb, cbf_cr) of the coded block flags (CBF) of the palette blocks can be set equal to 1.

[0483] a. In one example, the CBF for the color palette block can always be set equal to 1.

[0484] b. One or more of the CBFs for the color palette block can depend on whether there are escape pixels in the current block.

[0485] i. In one example, when the color palette block has escape samples, its cbf can be set equal to 1.

[0486] ii. Alternatively, when the color palette block does not have escape samples, its cbf can be set equal to 0.

[0487] c. Alternatively, when accessing adjacent color palette codec blocks, they can be treated as intra codec blocks with a CBF equal to 1.

[0488] 31. For the color palette block, the difference between the luminance and / or chrominance QP applied to the color palette block and the QP derived for the block (e.g., Qp in the JVET - O2001 - vE specification Y or Qp′ Y ) can be set equal to a fixed value.

[0489] a. In one example, the luminance and / or chrominance QP offset can be set equal to 0.

[0490] b. In one example, the chrominance QP offset can be different for Cb and Cr.

[0491] c. In one example, the luminance QP offset and the chrominance QP offset can be different.

[0492] d. In one example, the chrominance QP offset can be indicated in the DPS / VPS / SPS / PPS / strip / tile / slice header.

[0493] 32. The number of color palette indices explicitly signaled or inferred for the current block, represented by Num PltIdx (e.g., num_palette_indices_minus1 + 1), can be limited to be greater than or equal to K.

[0494] a. In one example, K can be determined based on the current color palette size, escape flag, and / or other information of the color palette codec block. Let S be the current color palette size of the current block, and let E be the value of the escape presence flag (e.g., palette_escape_val_present_flag). Let BlkS be the current block size.

[0495] i. In one example, K can be set equal to S.

[0496] ii. Alternatively, in one example, K can be set equal to S + E.

[0497] iii. Alternatively, in one example, K can be set equal to (the number of predicted palette entries + the number of signalled palette entries + palette_escape_val_present_flag) (e.g., NumPredictedPaletteEntries + num_signalled_palette_entries + palette_escape_val_present_flag).

[0498] iv. Alternatively, in one example, K can be set equal to (the maximum value of the palette index (e.g., MaxPaletteIndex) plus 1).

[0499] v. Alternatively, in one example, K can be signalled to the decoder.

[0500] i. In one example, K can be a fixed integer value.

[0501] ii. In one example, K is an integer value and can be determined based on the following options:

[0502] 1. Decoding information of the previous coded block / current block

[0503] 2. Quantization parameters of the current block / adjacent (contiguous or non - contiguous) blocks

[0504] 3. Video content (e.g., screen content or natural content)

[0505] 4. Messages signalled in the DPS / SPS / VPS / PPS / APS / picture header / strip header / slice group header / largest coded unit (LCU) / coded unit (CU) / LCU row / LCU group / TU / PU block / video coding unit

[0506] 5. Position of the CU / PU / TU / block / video coding unit

[0507] 6. Block scale of the current block and / or its adjacent blocks

[0508] 7. Block shape of the current block and / or its adjacent blocks

[0509] 8. Indication of the color format (such as 4:2:0, 4:4:4, RGB or YUV)

[0510] 9. Coding tree structure (such as a binary tree or a single tree)

[0511] 10. Strip / group type and / or picture type

[0512] 11. Color component (e.g., can be applied only to the luminance component or the chrominance component)

[0513] 12. Temporal layer ID

[0514] 13. Profile / level / hierarchy

[0515] b. In one example, (Num PltIdx minus K) can be signaled / parsed instead of num_palette_indices_minus1.

[0516] i. Alternatively, in addition, it can be signaled only when (S + E) is not less than 1.

[0517] ii. In one example, the value of (Num PltIdx minus K) can be signaled using a binarization method, where the binary string of the binarization can have a prefix (e.g., truncated unary code) and / or a suffix using an m-th order EG code.

[0518] iii. In one example, the value of (Num PltIdx minus K) can be signaled using a truncated binary code binarization method.

[0519] iv. In one example, the value of (Num PltIdx minus K) can be signaled using a truncated unary code binarization method.

[0520] v. In one example, the value of (Num PltIdx minus K) can be signaled using an m-th order EG binarization method.

[0521] vi. In one example, the value of BlkS–K can be used as an input parameter (e.g., cMax) in the above binarization methods, for example, used as the maximum value for the truncated unary code / truncated binary code binarization methods.

[0522] c. In one example, the compliant bitstream must satisfy Num PltIdx greater than or equal to K.

[0523] d. In one example, the compliant bitstream must satisfy Num PltIdx less than or equal to K.

[0524] i. In one example, K’ is set to (block width * block height).

[0525] ii. In one example, K’ is set to (block width * block height - K).

[0526] 33. Whether and / or how the above method can be applied is based on:

[0527] a. Video content (e.g., screen content or natural content)

[0528] b. Messages signaled in DPS / SPS / VPS / PPS / APS / picture header / strip header / slice group header / largest coding unit (LCU) / coding unit (CU) / LCU row / LCU group / TU / PU block / video coding unit

[0529] c. Positions of CU / PU / TU / block / video coding unit

[0530] d. Block size of the current block and / or its neighboring blocks

[0531] e. Block shape of the current block and / or its neighboring blocks

[0532] f. Indication of color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0533] g. Coding tree structure (such as a binary tree or a single tree)

[0534] h. Strip / slice group type and / or picture type

[0535] i. Color component (e.g., it can be applied only to the luma component or the chroma component)

[0536] j. Temporal layer ID

[0537] k. Profile / level / hierarchy

[0538] l. Whether the current block has an escape sample.

[0539] i. In one example, the above method can be applied only when the current block has at least one escape sample.

[0540] m. Whether the current block is coded in lossless mode (e.g., cu_transquant_bypass_flag)

[0541] i. In one example, the above method can be applied only when the current block is not coded in lossless mode.

[0542] n. Whether lossless coding is enabled (e.g., transquant_bypass_enabled, cu_transquant_bypass_flag)

[0543] i. In one example, the above method can be applied only when lossless coding is disabled.

[0544] Related line - based CG palette mode

[0545] 34. It is possible to indicate whether these are escape samples for each CG.

[0546] a. In one example, for each CG, a syntax element (e.g., palette_escape_val_present_flag) can be sent in the bitstream to indicate whether there are escape samples.

[0547] i. In one example, palette_escape_val_present_flag can be signaled or inferred based on the CG size, the number of decoded samples in the current block, and / or the palette size of the current block.

[0548] b. In one example, for the current CG, when there are no escape samples, index adjustment can be applied.

[0549] c. In one example, for the current CG, when there are escape samples, index adjustment should not be applied.

[0550] d. In one example, the above method can be applied only when the current block contains escape samples.

[0551] 35. In the line-based CG palette mode, the use indication of the operation of copying the above index (e.g., copy_above_palette_indices_flag) can be context-free coded.

[0552] e. Alternatively, in one example, the use indication of the operation of copying the above index (e.g., copy_above_palette_indices_flag) can be bypass coded without using any context.

[0553] i. In one example, the use indication of the operation of copying the above index (e.g., copy_above_palette_indices_flag) and the copy flag in the current segment (e.g., run_copy_flag) can be signaled in an interleaved manner.

[0554] f. In one example, the use indication of the operation of copying the above index (e.g., copy_above_palette_indices_flag) can be encoded after signaling all the copy flags (e.g., run_copy_flag) in the current segment.

[0555] g. In one example, the use indication of the operation of copying the above index (e.g., copy_above_palette_indices_flag) and the signaled index can be encoded interleavedly.

[0556] h. The above method can also be applied to other palette-based coding modes.

[0557] 36. The copy flag, run type, use indication of the operation of copying the above index, and escape value can be signaled interleavedly.

[0558] i. In one example, the first copy flag, run type, use indication of the operation of copying the above index, and escape value can be encoded and decoded in sequence; followed by the second copy flag, run type, use indication of the operation of copying the above index, and escape value.

[0559] j. Alternatively, in addition, for a given CG, the above method can be applied.

[0560] 37. The line-based CG palette mode can be disabled for blocks with a size less than or equal to a given threshold (denoted as Th).

[0561] k. In one example, Th is equal to the number of samples of the segment in the line-based CG palette mode.

[0562] l. In one example, Th is a fixed value (e.g., 16) and can be based on

[0563] i. Video content (e.g., screen content or natural content)

[0564] ii. Messages signaled in DPS / SPS / VPS / PPS / APS / picture header / strip header / slice group header / largest coding unit (LCU) / coding unit (CU) / LCU row / LCU group / TU / PU block / video coding unit

[0565] iii. The position of CU / PU / TU / block / video coding unit

[0566] iv. The block size of the current block and / or its neighboring blocks

[0567] v. The block shape of the current block and / or its neighboring blocks

[0568] vi. Indication of color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0569] vii. Coding tree structure (such as binary tree or single tree)

[0570] viii. Strip / group type and / or picture type

[0571] ix. Color component (e.g., can be applied only to the luma component or the chroma component)

[0572] x. Temporal layer ID

[0573] xi. Profile / level / tier

[0574] xii. Quantization parameter of the current block

[0575] xiii. Whether the current block has an escape sample.

[0576] xiv. Whether lossless coding / decoding is enabled (e.g., transquant_bypass_enabled, cu_transquant_bypass_flag)

[0577] Related BDPCM

[0578] 38. When encoding a block using BDPCM and dividing it into multiple transform blocks or sub-blocks, residual prediction can be done at the block level, and residual signaling can be done at the sub-block / transform block level.

[0579] a. Alternatively, in addition, reconstruction of another sub-block is not allowed during the reconstruction of a sub-block.

[0580] b. Alternatively, residual prediction and residual signaling are done at the sub-block / transform block level.

[0581] i. In this way, reconstruction of another sub-block can be utilized during the reconstruction of a sub-block.

[0582] Related chrominance QP table

[0583] 39. For a given index, the value of the chroma QP table for the joint_cb_cr mode can be constrained by both the value of the chroma QP table for Cb and the value of the chroma QP table for Cr.

[0584] c. In one example, the value of the chroma QP table for the joint_cb_cr mode can be constrained between the value of the chroma QP table for Cb and the value of the chroma QP table for Cr (including the endpoints).

[0585] Related deblocking

[0586] 40. The MV comparison in deblocking can depend on whether an alternative half-pixel interpolation filter is used (e.g., indicated by hpelIfIdx in the JVET-O2001-vE specification).

[0587] d. In one example, blocks using different interpolation filters can be treated as having different MVs.

[0588] e. In one example, when dealing with alternative half - pixel interpolation filters, a constant offset can be added to the MV difference used for de - blocking comparison.

[0589] General claims

[0590] 41. Whether and / or how to apply the above - mentioned method can be based on:

[0591] a. Video content (e.g., screen content or natural content)

[0592] b. Messages signaled in the DPS / SPS / VPS / PPS / APS / picture header / strip header / slice group header / largest coding unit (LCU) / coding unit (CU) / LCU row / LCU group / TU / PU block / video coding unit

[0593] c. The position of the CU / PU / TU / block / video coding unit

[0594] d. The block scale of the current block and / or its neighboring blocks

[0595] e. The block shape of the current block and / or its neighboring blocks

[0596] f. The quantization parameter of the current block

[0597] g. Indication of the color format (such as 4:2:0, 4:4:4, RGB, or YUV)

[0598] h. Coding tree structure (such as a binary tree or a single tree)

[0599] i. Strip / slice group type and / or picture type

[0600] j. Color component (e.g., it can be applied only to the luma component or the chroma component)

[0601] k. Temporal layer ID

[0602] l. Profile / level / hierarchy

[0603] m. Whether the current block has an escape sample.

[0604] i. In one example, the above - mentioned method can be applied only when the current block has at least one escape sample.

[0605] n. Whether the current block is coded in lossless mode (e.g., cu_transquant_bypass_flag)

[0606] ii. In one example, the above method may be applied only when the current block is not encoded or decoded in lossless mode.

[0607] o. Whether lossless encoding / decoding is enabled (e.g., transquant_bypass_enabled, cu_transquant_bypass_flag)

[0608] 5. Embodiment

[0609] This embodiment is based on JVET-O2001-vE. The newly added text is included within double thick curly brackets, e.g., {{a}} indicates that "a" has been added. The deleted text is included within double thick square brackets, e.g., [[b]] indicates that "b" has been deleted.

[0610] 5.1 Embodiment #1

[0611] Decoding process for palette mode

[0612] The input to this process is:

[0613] – Position (xCb, yCb), which specifies the top-left luminance sample of the current block relative to the top-left luminance sample of the current picture.

[0614] – Variable startComp, which specifies the first color component in the palette table.

[0615] – Variable cIdx, which specifies the color component of the current block.

[0616] – Two variables nCbW and nCbH, which respectively specify the width and height of the current block.

[0617] The output of this process is an array recSamples[x][y] that specifies the reconstructed sample values for the block, where x = 0..nCbW - 1 and y = 0..nCbH - 1.

[0618] Depending on the value of cIdx, the variables nSubWidth and nSubHeight are derived as follows:

[0619] – If cIdx is equal to 0, then set nSubWidth to 1 and set nSubHeight to 1.

[0620] – Otherwise, set nSubWidth to SubWidthC and set nSubHeight to SubHeightC.

[0621] The (nCbW x nCbH) block of the reconstructed sample array recSamples at the position (xCb, yCb) is represented by recSamples[x][y], where x = 0..nCTbW-1 and y = 0..nCbH-1, and the value of recSamples[x][y] is derived as follows for each x in the range 0 to nCbW-1 and each y in the range 0 to nCbH-1:

[0622] – Derive the variables xL and yL as follows:

[0623] xL = palette_transpose_flag? x * nSubHeight : x * nSubWidth (8-268)

[0624] yL = palette_transpose_flag? y * nSubWidth : y * nSubHeight (8-269)

[0625] – Derive the variable bIsEscapeSample as follows:

[0626] – If PaletteIndexMap[xCb + xL][yCb + yL] is equal to MaxPaletteIndex and palette_escape_val_present_flag is equal to 1, then set bIsEscapeSample to be equal to 1.

[0627] – Otherwise, set bIsEscapeSample to be equal to 0.

[0628] – If bIsEscapeSample is equal to 0, then the following applies:

[0629] recSamples[x][y] = CurrentPaletteEntries[cIdx][PaletteIndexMap[xCb + xL][yCb + yL]] (8-270)

[0630] – Otherwise, if cu_transquant_bypass_flag is equal to 1, then the following applies:

[0631] recSamples[x][y] = PaletteEscapeVal[cIdx][xCb + xL][yCb + yL] (8-271)

[0632] – Otherwise (bIsEscapeSample equals 1 and cu_transquant_bypass_flag equals 0), then the following applies:

[0633] 1. Derive the quantization parameter qP as follows:

[0634] – If cIdx equals 0,

[0635] qP = Max(0, Qp′Y) (8-272)

[0636] – Otherwise, if cIdx equals 1,

[0637] qP = Max(0, Qp′Cb) (8-273)

[0638] – Otherwise (cIdx equals 2),

[0639] qP = Max(0, Qp′Cr) (8-274)

[0640] 2. Derive the variable bitDepth as follows:

[0641] bitDepth = (cIdx == 0)? BitDepth Y : BitDepth C (8-275)

[0642] 3. [Specify the list levelScale[] as levelScale[k] = {40, 45, 51, 57, 64, 72}, where k = 0..5.]

[0643] 4. The following applies:

[0644] [[tmpVal = (PaletteEscapeVal[cIdx][xCb+xL][yCb+yL] *

[0645] levelScale[qP % 6]) << (qP / 6) + 32) >> 6 (8-276)]]

[0646] {Set T to be equal to (internal_bit_depth – input_bit_depth) for component cIdx

[0647] Nbits = max(T, (qP – 4) / 6)

[0648] – If Nbits equals T

[0649] recSamples[x][y] = PaletteEscapeVal[cIdx][xCb + xL][yCb + yL] << Nbits

[0650] – Otherwise

[0651] recSamples[x][y] = (PaletteEscapeVal[cIdx][xCb + xL][yCb + yL] << Nbits) + (1 << (Nbits - 1)}}

[0652] [[recSamples[x][y] = Clip3(0, (1 << bitDepth) - 1, tmpVal) (8 - 277)]]

[0653] When one of the following conditions is true:

[0654] – cIdx is equal to 0 and numComps is equal to 1;

[0655] – cIdx is equal to 2;

[0656] Derive or modify the variables PredictorPaletteSize[startComp] and the array PredictorPaletteEntries as follows:

[0657]

[0658]

[0659] A requirement for bitstream consistency is that the value of PredictorPaletteSize[startComp] must be in the range from 0 to PaletteMaxPredictorSize (including the endpoints).

[0660] 5.2 Example #2

[0661] This example describes palette index derivation.

[0662] Palette coding and decoding semantics

[0663] [[Derive the variable adjustedRefPaletteIndex as follows:

[0664]

[0665]

[0666] When CopyAboveIndicesFlag[xC][yC] is equal to 0, derive the variable

[0667] Current palette index:

[0668] if (Current palette index >= adjusted reference palette index)

[0669] Current palette index++

[0670] Binaryization process for palette_idx_idc

[0671] The input to this process is a request for binaryization of the syntax element palette_idx_idc and the variable MaxPaletteIndex.

[0672] The output of this process is the binaryization of the syntax element.

[0673] Derive the variable cMax as follows:

[0674] – [[If this process is called for the first time for the current block]], then set cMax equal to MaxPaletteIndex.

[0675] – [[Otherwise (if this process is not called for the first time for the current block), then set cMax equal to MaxPaletteIndex minus 1.]]

[0676] Derive the binaryization for palette_idx_idc by calling the TB binaryization process specified in Clause 9.3.3.4 with cMax.

[0677] 5.3 Example #3

[0678] Table 9-77 – Syntax elements and associated binaryization

[0679]

[0680] 8.4.5.3 Decoding process for palette mode

[0681] The input to this process is:

[0682] – Position (xCb, yCb), specifying the top-left luminance sample of the current block relative to the top-left luminance sample of the current picture

[0683] – Variable startComp, specifying the first color component in the palette table

[0684] – Variable cIdx, specifying the color component of the current block

[0685] – Two variables nCbW and nCbH, which respectively specify the width and height of the current block.

[0686] The output of this process is an array recSamples[x][y] that specifies the reconstructed sample values for the block, where x = 0..nCbW-1 and y = 0..nCbH-1.

[0687] Derive the variables nSubWidth and nSubHeight as follows based on the value of cIdx:

[0688] …

[0689] – Otherwise (bIsEscapeSample equals 1 and cu_transquant_bypass_flag equals 0), then the following applies:

[0690] 5. Derive the quantization parameter qP as follows:

[0691] – If cIdx equals 0,

[0692] qP = Max(0, Qp′Y) (8-272)

[0693] – Otherwise, if cIdx equals 1,

[0694] qP = Max(0, Qp′Cb) (8-273)

[0695] – Otherwise (cIdx equals 2),

[0696] qP = Max(0, Qp′Cr) (8-274)

[0697] 6. Derive the variable bitDepth as follows:

[0698] bitDepth = (cIdx == 0)? BitDepth Y : BitDepth C (8-275)

[0699] 7. [Specify the list levelScale[] as levelScale[k] = {40, 45, 51, 57, 64, 72}, where k = 0..5.]

[0700] 8. The following applies:

[0701] [[tmpVal = (PaletteEscapeVal[cIdx][xCb+xL][yCb+yL] * levelScale[qP % 6]) << (qP / 6) + 32) >> 6 (8-276)]]

[0702] {{shift=(max(QpPrimeTsMin,qP)-4) / 6

[0703] tmpVal=(PaletteEscapeVal[cIdx][xCb+xL][yCb+yL]<<shift)}}

[0704] recSamples[x][y]=Clip3(0,(1<<bitDepth)-1,tmpVal)(8 - 277)

[0705] 5.4 Example #4

[0706] It is stipulated that when copy_above_palette_indices_flag equals 1: if horizontal traversal scanning is used, the palette index is equal to the palette index at the same position in the upper row; if vertical traversal scanning is used, the palette index is equal to the palette index at the same position in the left column. It is stipulated that when copy_above_palette_indices_flag equals 0, the indication of the palette index of the sample points is encoded and decoded into the bitstream representation or this indication is inferred. ...

[0707] Derive the variable adjustedRefPaletteIndex as follows:

[0708]

[0709] When CopyAboveIndicesFlag[xC][yC] equals 0, derive the variable CurrPaletteIndex as follows:

[0710] if(CurrPaletteIndex >= adjustedRefPaletteIndex)

[0711] CurrPaletteIndex++(7 - 158)

[0712] 5.5 Example #5

[0713] Table 9 - 77 Syntax Elements and Associated Binarization

[0714]

[0715] 8.4.5.3 Decoding Process for Palette Mode

[0716] The input of this process is:

[0717] – The position (xCb, yCb) specifies the top-left luma sample of the current block relative to the top-left luma sample of the current picture.

[0718] – The variable startComp specifies the first color component in the palette table.

[0719] – The variable cIdx specifies the color component of the current block.

[0720] – Two variables nCbW and nCbH specify the width and height of the current block respectively.

[0721] The output of this process is an array recSamples[x][y] that specifies the reconstructed sample values for the block, where x = 0..nCbW-1 and y = 0..nCbH-1.

[0722] Depending on the value of cIdx, the variables nSubWidth and nSubHeight are derived as follows:

[0723] …

[0724] – Otherwise (bIsEscapeSample equals 1 and cu_transquant_bypass_flag equals 0), the following applies:

[0725] 9. The quantization parameter qP is derived as follows:

[0726] – If cIdx equals 0,

[0727] qP = Max(0, Qp′Y) (8-272)

[0728] – Otherwise, if cIdx equals 1,

[0729] qP = Max(0, Qp′Cb) (8-273)

[0730] – Otherwise (cIdx equals 2),

[0731] qP = Max(0, Qp′Cr) (8-274)

[0732] 10. The variable bitDepth is derived as follows:

[0733] bitDepth = (cIdx == 0)? BitDepth Y : BitDepth C (8-275)

[0734] 11. [Specify the list levelScale[] as levelScale[k] = {40, 45, 51, 57, 64, 72}, where k = 0..5.]

[0735] The following applies:

[0736] [[tmpVal = (PaletteEscapeVal[cIdx][xCb + xL][yCb + yL] * levelScale[qP % 6]) << (qP / 6) + 32) >> 6 (8 - 276)]]

[0737] {{shift = min(bitDepth - 1, (max(QpPrimeTsMin, qP) - 4) / 6)

[0738] tmpVal = (PaletteEscapeVal[cIdx][xCb + xL][yCb + yL] << shift)}}

[0739] recSamples[x][y] = Clip3(0, (1 << bitDepth) - 1, tmpVal) (8 - 277)

[0740] 5.6 Example #6

[0741] This example shows a design that skips transform shifting to achieve transform skip and is based on JVET - O2001 - vE.

[0742] 8.7.2 Scaling and Transform Process

[0743] The inputs to this process are:

[0744] – The luminance position (xTbY, yTbY), which specifies the top - left sample of the current luminance transform block relative to the top - left luminance sample of the current picture,

[0745] – The variable cIdx, which specifies the color component of the current block,

[0746] – The variable nTbW that specifies the width of the transform block,

[0747] – The variable nTbH that specifies the height of the transform block.

[0748] The output of this process is an (nTbW) x (nTbH) array of residual samples resSamples[x][y], where x = 0..nTbW - 1 and y = 0..nTbH - 1.

[0749] The variables bitDepth, bdShift, and tsShift are derived as follows:

[0750] bitDepth = (cIdx == 0)? BitDepth Y :

[0751] BitDepth C (8-942)

[0752] bdShift = Max(20 - bitDepth, 0) (8-943)

[0753] [[tsShift = 5 + ((Log2(nTbW) + Log2(nTbH)) / 2) (8 944)]]

[0754] Derive the variable codedCIdx as follows:

[0755] – If cIdx is equal to 0 or TuCResMode[xTbY][yTbY] is equal to 0, then set codedCIdx to be equal to cIdx.

[0756] – Otherwise, if TuCResMode[xTbY][yTbY] is equal to 1 or 2, then set codedCIdx to be equal to 1.

[0757] – Otherwise, set codedCIdx to be equal to 2.

[0758] Set the variable cSign to be equal to (1 - 2 * slice_joint_cbcr_sign_flag).

[0759] Derive the (nTbW) x (nTbH) array of residual samples resSamples as follows.

[0760] 1. Call the scaling process for transform coefficients as specified in Clause 8.7.3 with the transform block position (xTbY, yTbY), transform block width nTbW, transform block height nTbH, the color component variable cIdx set to be equal to codedCIdx, and the bit depth bitDepth of the current color component as inputs, and the output is the (nTbW) x (nTbH) array d of scaled transform coefficients.

[0761] 2. Derive the (nTbW) x (nTbH) array r of residual samples as follows:

[0762] – [[If transform_skip_flag[xTbY][yTbY] is equal to 1 and cIdx is equal to 0, then derive the residual sample array value r[x][y] as follows, where x = 0..nTbW - 1, y = 0..nTbH - 1:

[0763] r[x][y] = d[x][y] << tsShift

[0764] (8 - 945)]]

[0765] – Otherwise (transform_skip_flag[xTbY][yTbY] equals 0 or / and cIdx is not equal to 0), call the transform process for the scaled transform coefficients as specified in Clause 8.7.4.1 with the transform block position (xTbY, yTbY), transform block width nTbW, transform block height nTbH, color component variable cIdx, and the (nTbW)x(nTbH) array d of scaled transform coefficients as input, and the output is the (nTbW)x(nTbH) array r of residual samples.

[0766] 3. Derive the intermediate residual sample res[x][y] as follows, where x = 0..nTbW - 1 and y = 0..nTbH - 1:

[0767] – If transform_skip_flag[xTbY][yTbY] equals 1 and cIdx equals 0, then the following applies:

[0768] res[x][y] = d[x][y]}}

[0769] – Otherwise ((transform_skip_flag[xTbY][yTbY] equals 0 or cIdx is not equal to 0), then the following applies:}}

[0770] res[x][y] = (r[x][y] + (1 << (bdShift - 1))) >> bdShift (8 - 946)

[0771] 4. Derive the residual sample resSamples[x][y] as follows, where x = 0..nTbW - 1 and y = 0..nTbH - 1:

[0772] – If cIdx equals codedCIdx, then the following applies:

[0773] resSamples[x][y] = res[x][y] (8 - 947)

[0774] – Otherwise, if TuCResMode[xTbY][yTbY] equals 2, then the following applies:

[0775] resSamples[x][y] = cSign * res[x][y] (8 - 948)

[0776] – Otherwise, the following applies:

[0777] resSamples[x][y] = (cSign * res[x][y]) >> 1 (8 - 949)

[0778] 8.7.3 Scaling Process of Transform Coefficients

[0779] …

[0780] Derive the variable rectNonTsFlag as follows:

[0781] rect[[NonTs]]Flag = (((Log2(nTbW) + Log2(nTbH)) & 1) == 1[[&&]] (8 - 955)

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

[0783] Derive the variables bdShift, rectNorm, and bdOffset as follows:

[0784] - {{If transform_skip_flag[xTbY][yTbY] equals 1 and cIdx equals 0, then the following applies:

[0785] bdShift = 10}}

[0786] - {{Otherwise, the following applies:}}

[0787] bdShift = bitDepth + ((rect[[NonTs]]Flag? 1 : 0) + (8 - 956)

[0788] (Log2(nTbW) + Log2(nTbH)) / 2) - 5 + dep_quant_enabled_flagbdOffset = (1 << bdShift) >> 1 (8 - 957)

[0789] Define the list levelScale[][] as levelScale[j][k] = {{40, 45, 51, 57, 64, 72}, {57, 64, 72, 80, 90, 102}}, where j = 0..1, k = 0..5.

[0790] Set the (nTbW) x (nTbH) array dz to be equal to the (nTbW) x (nTbH) array TransCoeffLevel[xTbY][yTbY][cIdx].[[]]

[0791] For the derivation of the scaled transform coefficient d[x][y], where x = 0..nTbW-1 and y = 0..nTbH-1, the following applies:

[0792] – Derive the intermediate scaling factor m[x][y] as follows:

[0793] – If one or more of the following conditions are true, then set m[x][y] equal to 16:

[0794] – sps_scaling_list_enabled_flag is equal to 0.

[0795] – transform_skip_flag[xTbY][yTbY] is equal to 1.

[0796] – Otherwise, the following applies:

[0797] m[x][y] =

[0798] ScalingFactor[Log2(nTbW)][Log2(nTbH)][matrixId][x][y],

[0799] with matrixId as specified in

[0800] Table 7-5 (8-958)

[0801] – Derive the scaling factor ls[x][y] as follows:

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

[0803] ls[x][y] = (m[x][y] * levelScale[rect[[NonTs]]Flag][(qP + 1) % 6]) << ((qP + 1) / 6) (8-959)

[0804] – Otherwise (dep_quant_enabled_flag is equal to 0), the following applies:

[0805] ls[x][y] = (m[x][y] * levelScale[rect[[NonTs]]Flag][qP % 6]) << (qP / 6)(8-960)

[0806] – When BdpcmFlag[xTbY][yYbY] is equal to 1, modify dz[x][y] as follows:

[0807] – If BdpcmDir[xTbY][yYbY] is equal to 0 and x is greater than 0, then the following applies:

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

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

[0810] dz[x][y] = Clip3(CoeffMin, CoeffMax,

[0811] dz[x][y - 1]+dz[x][y]) (8 - 962)

[0812] – Derive the value of dnc[x][y] as follows:

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

[0814] – Derive the scaled transform coefficient d[x][y] as follows:

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

[0816] 5.7 Example #7

[0817] This example illustrates the design of signaling the number of palette indices.

[0818] 7.3.8.6 Palette codec syntax

[0819]

[0820]

[0821] Num_palette_indices{{_diff}}[[_minus1]] plus [[1]]({{MaxPaletteIndex + 1}}) is the number of palette indices explicitly signaled or inferred for the current block.

[0822] {{Set NumPaletteIndices to (num_palette_indices_diff + MaxPaletteIndex + 1).}}

[0823] When num_palette_indices{{_diff}}[[_minus1]] does not exist, it is inferred to be equal to 0.

[0824] {{The value of num_palette_indices_diff must be in the range of 0 to cbWidth * cbHeight – (MaxPaletteIndex + 1) (inclusive of the endpoints).}}

[0825] copy_above_indices_for_final_run_flag being equal to 1 specifies that if horizontal traversal scan is used, then copy the palette index at the last position in this coding unit from the palette indices in the upper row; if vertical traversal scan is used, then copy the palette index at the last position in this coding unit from the palette indices in the left column. copy_above_indices_for_final_run_flag being equal to 0 specifies to copy the palette index at the last position in this coding unit from PaletteIndexIdc[[[num_palette_indices_minus1]]{{NumPaletteIndices - 1}}].

[0826] 9.5.3.13 Binary process for num_palette_indices{{_diff}}[[_minus1]] The input to this process is a request for binarization of the syntax element num_palette_indices{{_diff}}[[_minus1]] and MaxPaletteIndex.

[0827] The output of this process is the binarization of this syntax element.

[0828] Derive the variable cRiceParam as follows:

[0829] cRiceParam = 3 + ((MaxPaletteIndex + 1) >> 3)

[0830] (9 - 26)

[0831] Derive the variable cMax from cRiceParam as:

[0832] cMax = 4 << cRiceParam (9 - 27)

[0833] The binary value of the syntax element num_palette_indices{{_diff}}[[_minus1]] is the concatenation of a prefix binary string and (when present) a suffix binary string.

[0834] For the derivation of the prefix binary string, the following applies:

[0835] – Derive the prefix value prefixVal of num_palette_indices{{_diff}}[[_minus1]] as follows:

[0836] prefixVal = Min(cMax, num_palette_indices{{_diff}}[[_minus1]]) (9-28)

[0837] – Specify the prefix binary string by calling the TR binary value process specified for prefixVal in Clause 9.3.3.3 with variables cMax and cRiceParam as inputs.

[0838] When the prefix binary string is equal to a bit string of length 4 and all bits are equal to 1, there is a suffix binary string and its derivation is as follows:

[0839] – Derive the suffix value suffixVal of num_palette_indices{{_diff}}[[_minus1]] as follows:

[0840] suffixVal = num_palette_indices{{_diff}}[[_minus1]] – cMax (9-29)

[0841] – Specify the suffix binary string by calling the k-order EGk binary value process specified for suffixVal in Clause 9.3.3.5 with the exponent Columbus order k set to be equal to cRiceParam + 1.

[0842] Table 9-77 Syntax Elements and Associated Binary Values

[0843]

[0844] Table 9-82 – ctxInc Assignment for Syntax Elements with Context Decoded Bits

[0845] 5.8 Example #8

[0846] This embodiment shows the design of interleaved signaling notification in a line-based CG palette mode.

[0847] This embodiment is based on the draft provided in JVET-P2001-v4.

[0848]

[0849]

[0850]

[0851]

[0852]

[0853] Figure 9 is a block diagram of a video processing apparatus 900. The apparatus 900 can be used to implement one or more of the methods described herein. The apparatus 900 can be embodied in a smart phone, a tablet computer, a computer, an Internet of Things (IoT) receiver, etc. The apparatus 900 can include one or more processors 902, one or more memories 904, and video processing hardware 906. The (one or more) processors 902 can be configured to implement one or more of the methods described in this document. The (one or more) memories 904 can be used to store data and code for implementing the methods and techniques described herein. The video processing hardware 906 can be used to implement some of the techniques described in this document in hardware circuitry. In some embodiments, the hardware 906 can be at least partially within the processor 902 (e.g., a graphics coprocessor).

[0854] Some embodiments of the disclosed technology include making a decision or determination to enable a video processing tool or mode. In one example, when a video processing tool or mode is enabled, the encoder will use or implement the tool or mode in the processing of video blocks, but will not necessarily modify the resulting bitstream based on the use of the tool or mode. That is, when a video processing tool or mode is enabled based on a decision or determination, the conversion from video blocks to a bitstream representation of the video will use the video processing tool or mode. In another example, when a video processing tool or mode is enabled, the decoder will process the bitstream knowing that the bitstream has been modified based on the video processing tool or mode. That is, the conversion from the bitstream representation of the video to video blocks will be performed using the video processing tool or mode enabled based on the decision or determination.

[0855] Some embodiments of the disclosed technology include making a decision or determination to disable a video processing tool or mode. In one example, when a video processing tool or mode is disabled, the encoder will not use the tool or mode in converting video blocks to a bitstream representation of the video. In another example, when a video processing tool or mode is disabled, the decoder will process the bitstream knowing that a video processing tool or mode that was enabled based on the decision or determination was not used to modify the bitstream.

[0856] Figure 10 FIG. 4 is a block diagram illustrating an exemplary video processing system 1000 in which various techniques disclosed herein may be implemented. Various embodiments may include some or all of the components of system 1000. System 1000 may include an input 1002 for receiving video content. The video content may be received in an original or uncompressed format, such as 8-bit or 10-bit multi-component pixel values, or may have a compressed or encoded format. Input 1002 may represent a network interface, a peripheral bus interface, or a storage interface. Examples of network interfaces include wired interfaces such as Ethernet, Passive Optical Network (PON), etc., and wireless interfaces such as Wi-Fi or cellular interfaces.

[0857] System 1000 may include an encoding component 1004, which may implement various encoding or coding methods described in this document. Encoding component 1004 may reduce the average bitrate of the video from the input 1002 to the output of encoding component 1004 to produce an encoded representation of the video. Thus, encoding techniques are sometimes referred to as video compression or video transcoding techniques. The output of encoding component 1004 may be stored or transmitted via a connected communication, as represented by component 1006. The stored or communicated bitstream (or encoded) representation of the video received at input 1002 may be used by component 1008 to generate pixel values or a displayable video to be sent to display interface 1010. The process of generating a user-viewable video from the bitstream representation is sometimes referred to as video decompression. Additionally, although certain video processing operations are referred to as "encoding" operations or tools, it should be understood that the encoding tools or operations are used at the encoder, and the corresponding decoding tools or operations that reverse the encoding results will be performed by the decoder.

[0858] Examples of peripheral bus interfaces or display interfaces may include Universal Serial Bus (USB), High-Definition Multimedia Interface (HDMI), or Displayport, etc. Examples of storage interfaces include SATA (Serial Advanced Technology Attachment), PCI, IDE interfaces, etc. The techniques described in this document may be embodied in various electronic devices, such as mobile phones, laptops, smartphones, or other devices capable of performing digital data processing and / or video display.

[0859] Figure 11is a block diagram showing an exemplary video coding system 100 that may utilize the techniques of the present disclosure.

[0860] As Figure 11 shown, the video coding system 100 may include a source device 110 and a destination device 120. The source device 110, which may be referred to as a video coding device, generates encoded video data. The destination device 120, which may be referred to as a video decoding device, may decode the encoded video data generated by the source device 110.

[0861] The source device 110 may include a video source 112, a video encoder 114, and an input / output (I / O) interface 116.

[0862] The video source 112 may include sources such as a video capture device, an interface for receiving video data from a video content provider, and / or a computer graphics system for generating video data, or a combination of such sources. The video data includes one or more pictures. The video encoder 114 encodes the video data from the video source 112 to generate a bitstream. The bitstream may include a sequence of bits forming an encoded representation of the video data. The bitstream may include encoded pictures and associated data. An encoded picture is an encoded representation of a picture. The associated data may include sequence parameter sets, picture parameter sets, and other syntax structures. The I / O interface 116 may include a modulator / demodulator (modem) and / or a transmitter. The encoded video data may be directly transmitted via the interface 116 to the destination device 120 over a network 130a. The encoded video data may also be stored on a storage medium / server 130b for access by the destination device 120.

[0863] The destination device 120 may include an I / O interface 126, a video decoder 124, and a display device 122.

[0864] The I / O interface 126 may include a receiver and / or a modem. The I / O interface 126 may obtain the encoded video data from the source device 110 or the storage medium / server 130b. The video decoder 124 may decode the encoded video data. The display device 122 may display the decoded video data to a user. The display device 122 may be integrated with the destination device 120 or may be external to the destination device 120 configured to interface with an external display device.

[0865] The video encoder 114 and the video decoder 124 may operate according to a video compression standard, such as the High Efficiency Video Coding (HEVC) standard, the Versatile Video Coding (VVC) standard, and other current and / or future standards.

[0866] Figure 12 is a block diagram of an example of a video encoder 200, which may beFigure 11 The video encoder 114 in the system 100 shown in

[0867] The video encoder 200 may be configured to perform any or all of the techniques of the present disclosure. In Figure 12 an example, the video encoder 200 includes multiple functional components. The techniques described in the present disclosure may be shared among various components of the video encoder 200. In some examples, a processor may be configured to perform any or all of the techniques of the present disclosure.

[0868] The functional components of the video encoder 200 may include: a segmentation unit 201, a prediction unit 202 that may include a mode selection unit 203, a motion estimation unit 204, a motion compensation unit 205, and an intra prediction unit 206, a residual generation unit 207, a transformation unit 208, a quantization unit 209, an inverse quantization unit 210, an inverse transformation unit 211, a reconstruction unit 212, a buffer 213, and an entropy coding / decoding unit 214.

[0869] In other examples, the video encoder 200 may include more, fewer, or different functional components. In an example, the prediction unit 202 may include an intra block copy (IBC) unit. The IBC unit may perform prediction in the IBC mode, in which at least one reference picture is the picture in which the current video block is located.

[0870] In addition, some components (such as the motion estimation unit 204 and the motion compensation unit 205) may be highly integrated, but are separately shown in Figure 12 for purposes of explanation.

[0871] The segmentation unit 201 may segment a picture into one or more video blocks. The video encoder 200 and the video decoder 300 may support various video block sizes.

[0872] The mode selection unit 203 may select one of the encoding modes (e.g., intra or inter), for example, based on an error result; and provide the resulting intra or inter coded / decoded block to the residual generation unit 207 to generate residual block data, and to the reconstruction unit 212 to reconstruct the coded / decoded block for use as a reference picture. In some examples, the mode selection unit 203 may select a combination of intra and inter prediction (CIIP) mode, in which the prediction is based on an inter prediction signal and an intra prediction signal. The mode selection unit 203 may also select a motion vector resolution (e.g., sub-pixel or integer pixel accuracy) for a block in the case of inter prediction.

[0873] To perform inter prediction on the current video block, the motion estimation unit 204 may generate motion information for the current video block by comparing one or more reference frames from the cache 213 with the current video block. The motion compensation unit 205 may determine a predicted video block for the current video block based on the motion information and decoded samples of pictures from the cache 213 other than the picture associated with the current video block.

[0874] The motion estimation unit 204 and the motion compensation unit 205 may perform different operations for the current video block. For example, it depends on whether the current video block is an I-slice, a P-slice, or a B-slice.

[0875] In some examples, the motion estimation unit 204 may perform uni-directional prediction on the current video block, and the motion estimation unit 204 may search the reference pictures in list 0 or list 1 to obtain a reference video block for the current video block. Thereafter, the motion estimation unit 204 may generate a reference index indicating the reference picture in list 0 or list 1 that contains the reference video block and a motion vector indicating the spatial displacement between the current video block and the reference video block. The motion estimation unit 204 may output the reference index, the prediction direction indicator, and the motion vector as the motion information for the current video block. The motion compensation unit 205 may generate a predicted video block for the current block based on the reference video block indicated by the motion information of the current video block.

[0876] In other examples, the motion estimation unit 204 may perform uni-directional prediction on the current video block. The motion estimation unit 204 may search the reference pictures in list 0 to obtain a reference video block for the current video block and may also search the reference pictures in list 1 to obtain another reference video block for the current video block. Thereafter, the motion estimation unit 204 may generate reference indices indicating the reference pictures in list 0 and list 1 that contain these reference video blocks and motion vectors indicating the spatial displacements between these reference video blocks and the current video block. The motion estimation unit 204 may output these reference indices and motion vectors of the current video block as the motion information for the current video block. The motion compensation unit 205 may generate a predicted video block for the current block based on these reference video blocks indicated by the motion information of the current video block.

[0877] In some examples, the motion estimation unit 204 may output the entire set of motion information for use in the decoding process of the decoder.

[0878] In some examples, the motion estimation unit 204 does not output the entire set of motion information for the current video. Instead, the motion estimation unit 204 may signal the motion information for the current video block in the context of referring to the motion information of another video block. For example, the motion estimation unit 204 may determine that the motion information of the current video block is sufficiently similar to the motion information of an adjacent video block.

[0879] In one example, the motion estimation unit 204 may indicate a value in the syntax structure associated with the current video block, and this value indicates to the video decoder 300 that the current video block has the same motion information as another video block.

[0880] In another example, the motion estimation unit 204 may mark another video block and a motion vector difference (MVD) in the syntax structure associated with the current video block. The motion vector difference indicates the difference between the motion vector of the current video block and the motion vector of the indicated video block. The video decoder 300 may use the motion vector of the indicated video block and this motion vector difference to determine the motion vector of the current video block.

[0881] As discussed above, the video encoder 200 may predictively signal motion vectors. Two examples of predictive signaling techniques that may be implemented by the video encoder 200 include advanced motion vector prediction (AMVP) and Merge mode signaling.

[0882] The intra prediction unit 206 may perform intra prediction on the current video block. When the intra prediction unit 206 performs intra prediction on the current video block, the intra prediction unit 206 may generate prediction data for the current video block based on decoded samples of other video blocks within the same picture. The prediction data for the current video block may include a predicted video block and various syntax elements.

[0883] The residual generation unit 207 may generate residual data for the current video block by subtracting (e.g., indicated by a subtraction sign) the predicted video block of the current video block from the current video block. The residual data for the current video block may include residual video blocks corresponding to different sample components of the samples in the current video block.

[0884] In other examples, there may be no residual data for the current video block in (e.g.) the skip mode, and the residual generation unit 207 may not perform a subtraction operation.

[0885] The transform processing unit 208 may generate one or more transform coefficient video blocks for the current video block by applying one or more transforms to the residual video block associated with the current video block.

[0886] After the transform processing unit 208 generates the transform coefficient video block associated with the current video block, the quantization unit 209 may quantize the transform coefficient video block associated with the current video block based on one or more quantization parameters (QP) associated with the current video block.

[0887] The inverse quantization unit 210 and the inverse transform unit 211 can respectively apply inverse quantization and inverse transform to the transformed coefficient video block, thereby reconstructing the residual video block from the transformed coefficient video block. The reconstruction unit 212 can add the reconstructed residual video block to the corresponding samples of one or more predicted video blocks generated by the prediction unit 202, thereby generating a reconstructed video block associated with the current block for storage in the buffer 213.

[0888] After the reconstruction unit 212 reconstructs the video block, an in-loop filtering operation can be performed to reduce video blockiness artifacts within the video block.

[0889] The entropy encoding / decoding unit 214 can receive data from other functional components of the video encoder 200. When the entropy encoding / decoding unit 214 receives the data, the entropy encoding / decoding unit 214 can perform one or more entropy encoding operations to generate entropy encoded data and output a bitstream containing the entropy encoded data.

[0890] Figure 13 is a block diagram showing an example of the video decoder 300, and the video decoder 300 can be Figure 11 the video decoder 114 in the system 100 shown in

[0891] The video decoder 300 can be configured to perform any or all of the techniques of the present disclosure. In Figure 13 the example, the video decoder 300 includes multiple functional components. The techniques described in the present disclosure can be shared among various components of the video decoder 300. In some examples, a processor can be configured to perform any or all of the techniques of the present disclosure.

[0892] In Figure 13 the example, the video decoder 300 includes an entropy decoding unit 301, a motion compensation unit 302, an intra prediction unit 303, an inverse quantization unit 304, an inverse transform unit 305, a reconstruction unit 306, and a buffer 307. The video decoder 300 can (in some examples) perform a decoding pass that is substantially reciprocal to the encoding pass described in connection with the video encoder 200 ( Figure 12 ).

[0893] The entropy decoding unit 301 can retrieve the encoded bitstream. The encoded bitstream can include entropy encoded video data (e.g., coded blocks of video data). The entropy decoding unit 301 can decode the entropy encoded video data, and the motion compensation unit 302 can determine motion information including motion vectors, motion vector predictions, reference picture list indices, and other motion information from the entropy decoded video data. The motion compensation unit 302 can determine such information (e.g.,) by performing AMVP and merge mode.

[0894] The motion compensation unit 302 may generate motion-compensated blocks, which may perform interpolation based on an interpolation filter. An identifier of the interpolation filter used in combination with sub-pixel accuracy may be included in the syntax element.

[0895] The motion compensation unit 302 may use the interpolation filters such as those used by the video encoder 200 during the encoding of video blocks to calculate the interpolation of sub-integer pixels for a reference block. The motion compensation unit 302 may determine the interpolation filters used by the video encoder 200 according to the received syntax element, and generate a prediction block using these interpolation filters.

[0896] The motion compensation unit 302 may use some information in the syntax information for determining the size of the blocks for encoding and / or decoding frames and / or slices of an encoded video sequence, the partitioning information describing how each macroblock of a picture of the encoded video sequence is partitioned, the mode indicating how each partition is encoded, one or more reference frames (and reference frame lists) for each inter-coded block, and other information to decode the encoded video sequence.

[0897] The intra prediction unit 303 may form a prediction block from adjacent blocks using, for example, the intra prediction mode received in the bitstream. The inverse quantization unit 303 inverse quantizes the quantized video block coefficients provided in the bitstream and decoded by the entropy decoding unit 301, i.e., inverse quantization. The inverse transform unit 303 applies an inverse transform.

[0898] The reconstruction unit 306 may sum the residual block and the corresponding prediction block generated by the motion compensation unit 202 or the intra prediction unit 303 to form a decoded block. If desired, a deblocking filter may also be applied to filter the decoded block to remove blocking artifacts. Thereafter, the decoded video block is stored in the buffer 307, which provides reference blocks for subsequent motion compensation / intra prediction and also generates the decoded video for presentation on a display device.

[0899] In some embodiments, the following methods are based on the enumeration of the examples and embodiments above. In the examples, these methods may be implemented using (but not limited to using) Figures 9 - 13 the illustrated implementations.

[0900] Figure 14 is a flowchart of an exemplary method for video processing. As shown therein, method 1400 includes: at operation 1410, for the conversion between a video including one or more video regions including a current video block and a bitstream representation of the video, maintaining a palette prediction table for predicting a palette used in a palette mode decoding tool used for the current video block.

[0901] Method 1400 includes making a decision in operation 1420 to apply local dual-tree coding / decoding to the transformation.

[0902] Method 1400 includes performing the transformation in operation 1430 based on the decision.

[0903] Method 1400 includes performing the transformation in operation 1440 based on the palette prediction table after the modification. In some embodiments, the palette mode coding / decoding tool represents a palette of representative color values for the current video block, and the local dual-tree coding / decoding is capable of segmenting a chrominance block based on the block size independently of the corresponding luma block.

[0904] Figure 15 is a flowchart of an exemplary method for video processing. As shown therein, method 1500 includes: in operation 1510, performing a transformation between a video including one or more video regions including the current video block and a bitstream representation of the video, and the bitstream representation conforms to format rules that prohibit simultaneous use of palette mode coding / decoding and local dual-tree coding / decoding for the current video block. In some embodiments, the palette mode coding / decoding tool represents a palette of representative color values for the current video block, and the local dual-tree coding / decoding is capable of segmenting a chrominance block based on the block size independently of the corresponding luma block.

[0905] Figure 16 is a flowchart of an exemplary method for video processing. As shown therein, method 1600 includes: in operation 1610, performing a transformation between a video including one or more video regions including the current video block and a bitstream representation of the video, coding / decoding the video block into the bitstream representation using a palette coding / decoding mode, and selectively using a palette prediction table for predicting the palette for the transformation based on a condition.

[0906] The following solutions can be implemented together with the additional techniques described among the items (e.g., item 1) listed as preferred features in the previous section as some embodiments.

[0907] 1. A video processing method, comprising: maintaining a palette prediction table for predicting a palette used in a palette mode coding / decoding tool for a current video block for a transformation between a video including one or more video regions including the current video block and a bitstream representation of the video; making a decision to apply local dual-tree coding / decoding to the transformation; modifying the palette prediction table based on the decision; and performing the transformation based on the modified palette prediction table, wherein the palette mode coding / decoding tool represents a palette of representative color values for the current video block, and wherein local dual-tree coding / decoding is capable of segmenting a chrominance block based on the block size independently of the corresponding luma block.

[0908] 2. A method according to Solution 1, wherein the modification includes resetting a palette prediction table due to the application of local dual-tree encoding and decoding.

[0909] 3. A method according to Solution 1, wherein the modification includes removing duplicate palette entries from the palette prediction table due to the application of local dual-tree encoding and decoding.

[0910] 4. A method according to Solution 1, wherein the modification includes adding a constraint that determines that two entries are different when three components of the two entries in the palette prediction table are different.

[0911] 5. A method according to Solution 1, wherein the modification includes checking the palette entries in the palette prediction table and removing duplicate palette entries from the palette prediction table due to the application of local dual-tree encoding and decoding.

[0912] 6. A method according to Solution 1, wherein the modification includes applying full pruning or partial pruning to the palette entries in the palette prediction table when checking the palette entries.

[0913] 7. A method according to Solution 1, wherein the modification includes determining that two entries are equal when the luminance component values of the two entries in the palette prediction table are equal.

[0914] 8. A method according to Solution 1, wherein the modification is performed only on luminance blocks due to the application of local dual-tree encoding and decoding to the luminance component of the video.

[0915] 9. A method according to Solution 1, wherein the modification is performed only on chrominance blocks due to the application of local dual-tree encoding and decoding to the chrominance component of the video.

[0916] 10. A method according to Solution 1, wherein the palette predictor of the palette mode encoding and decoding tool is reset due to switching from single-tree encoding and decoding to local dual-tree encoding and decoding.

[0917] 11. A method according to Solution 1, wherein the palette predictor of the palette mode encoding and decoding tool is reset due to switching from local dual-tree encoding and decoding to single-tree encoding and decoding.

[0918] 12. A video processing method, comprising: performing a conversion between a video including one or more video regions containing a current video block and a bitstream representation of the video, wherein the bitstream representation conforms to format rules that prohibit the simultaneous use of palette mode encoding and decoding and local dual-tree encoding and decoding for the current video block, wherein the palette mode encoding and decoding tool represents the current video block using a palette of representative color values, and wherein local dual-tree encoding and decoding is capable of segmenting chrominance blocks independently of corresponding luminance blocks based on block size.

[0919] 13. A method according to solution 12, wherein palette mode encoding and decoding is enabled and local dual-tree encoding and decoding is disabled.

[0920] 14. A method according to solution 12, wherein palette mode encoding and decoding is disabled and local dual-tree encoding and decoding is enabled.

[0921] 15. A method according to solution 12, wherein local dual-tree encoding and decoding is disabled for the current video block when the video has a predetermined color format.

[0922] 16. A method according to solution 15, wherein the predetermined color format is 4:4:4.

[0923] 17. A method according to solution 12, wherein palette mode encoding and decoding is disabled when the type of local dual-tree encoding and decoding is MODE_TYPE_INTRA.

[0924] 18. A method according to solution 12, wherein the palette predictor of the palette mode encoding and decoding tool is reset due to the application of local dual-tree encoding and decoding.

[0925] 19. A method according to solution 12, wherein the signaling used for the entries of the palette predictor of the palette mode encoding and decoding tool is based on the type of local tree encoding.

[0926] 20. A video processing method, comprising: performing a conversion between a video including one or more video regions including a current video block and a bitstream representation of the video, wherein the video block is encoded and decoded into the bitstream representation using a palette encoding mode in which the video block is represented by a palette of representative color values, and wherein a palette prediction table for predicting the palette is selectively used for the conversion based on a condition.

[0927] 21. A method according to solution 20, wherein the condition specifies the number of color components included in the current palette entry that is different from the number of color components of the entries of the palette prediction table.

[0928] 22. A method according to solution 21, wherein the reuse flag of each entry of the palette prediction table is marked as true.

[0929] 23. A method according to solution 20, wherein the condition specifies that the reuse flag of each entry of the palette prediction table is marked as false when the current palette entry includes the number of color components that is different from the number of color components of the entries of the palette prediction table.

[0930] 24. A method according to solution 20, wherein the condition stipulates that the palette prediction table and the current palette table have different color components.

[0931] 25. A method according to solution 24, wherein the reuse flag of each entry in the palette prediction table is marked as true.

[0932] 26. A method according to solution 20, wherein the condition stipulates that when the palette prediction table and the current palette table have different color components, the reuse flag of each entry in the palette prediction table is marked as false.

[0933] 27. A method according to any one of solutions 1 to 26, wherein performing the conversion includes generating the bitstream representation from the one or more video regions.

[0934] 28. A method according to any one of solutions 1 to 26, wherein performing the conversion includes generating the one or more video regions from the bitstream representation.

[0935] 29. An apparatus in a video system, comprising a processor and a non-transitory memory having instructions stored thereon, wherein the instructions, when executed by the processor, cause the processor to implement a method according to any one of solutions 1 to 28.

[0936] 30. A computer program product stored on a non-transitory computer-readable medium, the computer program product including program code for implementing a method according to any one of solutions 1 to 28.

[0937] The disclosed and other solutions, examples, embodiments, modules, and functional operations described in this document can be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this document and their structural equivalents, or combinations of one or more of them. The disclosed embodiments and other embodiments can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer-readable medium for execution by, or to control the operation of, a data processing apparatus. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a storage device, a composition of matter affecting a machine-readable propagated signal, or a combination of one or more of them. The term “data processing apparatus” encompasses all apparatus, devices, and machines for processing data, including, by way of example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the apparatus can also include code that creates an execution environment for the contemplated computer program, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them. A propagated signal is an artificially generated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal, which is generated to encode information for transmission to an appropriate receiver apparatus.

[0938] A computer program (also called a program, software, software application, script, or code) can be written in any form of programming language, including a compiled or interpreted language, and can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program, or in multiple coordinated files (e.g., files that store one or more modules, subroutines, or portions of code). A computer program can be deployed to be executed on one or more computers that are located at one site or distributed across multiple sites and interconnected by a communication network.

[0939] The processes and logical flows described in this specification can be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. These processes and logical flows can also be performed by, and the apparatus can also be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).

[0940] For example, a processor suitable for executing a computer program includes general and special purpose microprocessors, as well as any one or more processors of any kind of digital computer. Generally speaking, a processor will receive instructions and data from a read-only memory or a random access memory or both. The basic elements of a computer are a processor that executes instructions and one or more storage devices that store instructions and data. Usually, a computer will also include one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks or optical disks, or is operatively coupled to receive data from or transfer data to one or more mass storage devices, or both. However, a computer does not necessarily have such devices. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including (for example) semiconductor storage devices such as EPROM, EEPROM and flash memory devices; magnetic disks such as internal hard disks or removable disks; magneto-optical disks; and CD ROM and DVD ROM disks. The processor and memory can be supplemented by, or incorporated in, special purpose logic circuitry.

[0941] Although this patent document contains many details, it should not be construed as limiting any subject matter or the scope of any claims, but rather as a description of specific features of particular embodiments of a particular technology. Certain features described in the context of separate embodiments of this patent document can also be implemented in combination in a single embodiment. Conversely, the various features described in the context of a single embodiment can also be implemented separately or in any suitable sub-combination in multiple embodiments. Moreover, although certain features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be removed from that combination, and the claimed combination can relate to a sub-combination or a variation of a sub-combination.

[0942] Similarly, although operations are shown in the drawings in a particular order, this should not be construed as requiring that such operations be performed in a sequential order or the particular order shown, or that all of the operations shown be performed to achieve a desired result. Additionally, the partitioning of various system components described in the context of the embodiments of this patent document should not be construed as requiring such partitioning in all embodiments.

[0943] Only a few embodiments and examples have been described, and other embodiments, enhancements and variations can be made based on what is described and illustrated in this patent document.

Claims

1. A video data processing method, comprising: For the conversion between the current luminance block of a video and the bitstream of the video, determining to apply a prediction mode to the current luminance block, wherein in the prediction mode, reconstructed samples are represented by a set of representative color values, and the set of representative color values includes at least one of the following: 1) a palette predictor, 2) an escape sample, or 3) palette information included in the bitstream; And Constructing a current palette for the current luminance block, the current palette including one or more palette predictors derived from a palette prediction table; Performing the conversion based on the current palette; Making a determination to apply local dual-tree coding / decoding to the current luminance block; and Based on the determination, modifying the palette prediction table according to the current palette, wherein the modification includes a reset process; Wherein at least one of the escape samples is reconstructed based on a clipping function and a quantization value of the escape sample; Wherein the reconstructed escape sample is determined based on Clip3(0, (1<<BitDepth)-1, tmpVal), where tmpVal is determined based on (m<<(qP / 6)+32)>>6), qP represents a quantization parameter, and m is determined based on the quantization value of the escape sample.

2. The method according to claim 1, wherein The local dual-tree coding / decoding disables the splitting of a chroma parent block and enables the splitting of a corresponding luma parent block based on the size of the chroma parent block; Wherein the luma parent block is generated from a luma coding tree block based on a luma splitting scheme including a recursive splitting operation, and the chroma parent block is generated from a chroma coding tree block based on a chroma splitting scheme having the same recursive splitting operation as the luma splitting scheme.

3. The method according to claim 1, wherein The reset process includes resetting the entries of the palette prediction table to fixed values.

4. The method according to claim 1, wherein, The qP is determined based on Max(QpPrimeTsMin, Qp'Y); Wherein QpPrimeTsMin represents the minimum allowable quantization parameter for the transform skip mode; and Wherein Qp'Y represents the luma quantization parameter.

5. The method according to claim 4, wherein, QpPrimeTsMin is defined as 6*n + 4, where n is the value of a syntax element included in the bitstream.

6. The method according to claim 5, wherein, The syntax element is included in the sequence level of the bitstream.

7. The method according to claim 1, wherein, The conversion includes encoding the current luminance block into the bitstream.

8. The method according to claim 1, wherein, The conversion includes decoding the current luminance block from the bitstream.

9. A device for processing video data, comprising a processor and a non-transitory memory having instructions thereon, wherein the instructions, when executed by the processor, cause the processor: For the conversion between the current luminance block of a video and the bitstream of the video, determining to apply a prediction mode to the current luminance block, wherein in the prediction mode, reconstructed samples are represented by a set of representative color values, and the set of representative color values includes at least one of the following: 1) a palette predictor, 2) an escape sample, or 3) palette information included in the bitstream; and Construct a current palette for the current luminance block that includes one or more palette predictors derived from a palette prediction table. Perform the transformation based on the current palette. Make a determination to apply local dual-tree coding / decoding to the current luminance block, and Based on the determination, modify the palette prediction table according to the current palette, where the modification includes a reset process. Among them, At least one of the escape samples is reconstructed based on a clipping function and the quantization value of the escape sample. Wherein, the reconstructed escape sample is determined based on Clip3(0, (1<<BitDepth)-1, tmpVal), where tmpVal is determined based on m<<(qP / 6)+32)>>6, qP represents the quantization parameter, and m is determined based on the quantization value of the escape sample.

10. The device according to claim 9, wherein, The local dual-tree coding / decoding disables the splitting of the chroma parent block and enables the splitting of the corresponding luma parent block based on the size of the chroma parent block. Wherein, the luma parent block is generated from a luma coding tree block based on a luma splitting scheme including a recursive splitting operation, and the chroma parent block is generated from a chroma coding tree block based on a chroma splitting scheme having the same recursive splitting operation as the luma splitting scheme.

11. The apparatus according to claim 9, wherein, The reset process includes resetting the entries of the palette prediction table to fixed values.

12. The apparatus according to claim 9, wherein the reconstructed escape sample is determined based on Max(QpPrimeTsMin, Qp'Y). Among them, QpPrimeTsMin represents the minimum allowable quantization parameter for the transform skip mode, and Wherein, Qp'Y represents the luma quantization parameter.

13. A non-transitory computer-readable storage medium storing instructions that cause a processor to: For the transformation between the current luminance block of a video and the bitstream of the video, determine to apply a prediction mode to the current luminance block, where in the prediction mode, the reconstructed samples are represented by a set of representative color values, and the set of representative color values includes at least one of the following: 1) a palette predictor, 2) an escape sample, or 3) palette information included in the bitstream; and Construct a current palette for the current luminance block that includes one or more palette predictors derived from a palette prediction table. Perform the transformation based on the current palette. Make a determination to apply local dual-tree coding / decoding to the current luminance block, and Based on the determination, modify the palette prediction table according to the current palette, where the modification includes a reset process. Among them, At least one of the escape samples is reconstructed based on a clipping function and the quantization value of the escape sample. Wherein, the reconstructed escape sample is determined based on Clip3(0, (1<<BitDepth)-1, tmpVal), where tmpVal is determined based on m<<(qP / 6)+32)>>6, qP represents the quantization parameter, and m is determined based on the quantization value of the escape sample.

14. The non-transitory computer-readable storage medium according to claim 13, wherein, The local dual-tree encoding and decoding disables the splitting of the chroma parent block based on the size of the chroma parent block and enables the splitting of the corresponding luma parent block. Wherein, the luma parent block is generated from a luma coding tree block based on a luma splitting scheme including a recursive splitting operation, and the chroma parent block is generated from a chroma coding tree block based on a chroma splitting scheme having the same recursive splitting operation as the luma splitting scheme.

15. The non-transitory computer-readable storage medium according to claim 13, wherein, The reset process includes resetting the entries of the palette prediction table to fixed values.

16. A method for storing a bitstream of a video, comprising: For a current luma block of the video, determining to apply a prediction mode to the current luma block, wherein in the prediction mode, reconstructed samples are represented by a set of representative color values, and the set of representative color values includes at least one of the following: 1) a palette predictor, 2) an escape sample, or 3) palette information included in the bitstream; And Constructing a current palette for the current luma block including one or more palette predictors derived from a palette prediction table, Generating the bitstream based on the current palette, Storing the bitstream in a non-transitory computer-readable recording medium, Making a determination to apply local dual-tree encoding and decoding to the current luma block, and Based on the determination, modifying the palette prediction table according to the current palette, wherein the modification includes a reset process, Wherein, at least one of the escape samples is reconstructed based on a clipping function and a quantization value of the escape sample, Wherein, the reconstructed escape sample is determined based on Clip3(0, (1<<BitDepth)-1, tmpVal), wherein, tmpVal is determined based on m<<(qP / 6)+32)>>6, qP represents a quantization parameter, and m is determined based on the quantization value of the escape sample.

Images