Image processing method and device for using palette mode

Abstract

To provide systems and methods for signaling and using a palette mode in video processing.SOLUTION: According to certain disclosed embodiments, an exemplary video processing method includes: receiving a first palette entry for palette-coding a target coding unit (CU); determining whether the target CU is part of a single-tree slice; determining whether the target CU is coded with separate luma and chroma trees; and, in response to the target CU being determined to be part of a single-tree slice and be coded with separate luma and chroma trees, decoding a first component of the target CU based on the first palette entry, and decoding a second component of the target CU based on a default palette entry.SELECTED DRAWING: Figure 6

Description

[Technical Field]

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This disclosure claims priority to U.S. Provisional Patent Application No. 62 / 943,083, filed December 3, 2019, and U.S. Provisional Patent Application No. 62 / 952,426, filed December 22, 2019, which are incorporated by reference in their entireties.

[0002] Technical Field

[0002] The present disclosure relates generally to video processing, and more particularly to methods and apparatus for signaling and using palette modes. [Background technology]

[0003] background

[0003] A video is a series of still pictures (or "frames") that capture visual information. To reduce storage memory and transmission bandwidth, video may be compressed before storage or transmission and decompressed before display. The compression process is usually called encoding, and the decompression process is usually called decoding. There are various video coding formats that use standardized video coding techniques, most commonly based on prediction, transform, quantization, entropy coding, and in-loop filtering. Video coding standards, such as the High Efficiency Video Coding (HEVC) / H.265 standard, the Versatile Video Coding (VVC) / H.266 standard, and the AVS standard, that specify specific video coding formats are developed by standardization organizations. As increasingly advanced video coding techniques are adopted into video standards, the coding efficiency of new video coding standards becomes increasingly higher. Summary of the Invention [Means for solving the problem]

[0004] Summary of the Disclosure

[0004] Embodiments of the present disclosure provide methods and apparatuses for signaling and using palette modes. In some example embodiments, a video processing method includes receiving a first palette entry for palette encoding a target coding unit (CU), determining whether the target CU is part of a single-tree slice, determining whether the target CU is encoded by separate luma and chroma trees, and, in response to determining that the target CU is part of the single-tree slice and is encoded by separate luma and chroma trees, decoding a first component of the target CU based on the first palette entry and decoding a second component of the target CU based on a default palette entry.

[0005] In some embodiments, an exemplary video processing device includes at least one memory for storing instructions and at least one processor. The at least one processor is configured to execute the instructions to cause the device to receive a first palette entry for palette encoding a target coding unit (CU), determine whether the target CU is part of a single tree slice, determine whether the target CU is encoded by separate luma and chroma trees, and, in response to determining that the target CU is part of the single tree slice and is encoded by separate luma and chroma trees, decode a first component of the target CU based on the first palette entry and decode a second component of the target CU based on a default palette entry.

[0006] In some embodiments, an exemplary non-transitory computer-readable storage medium stores a set of instructions executable by one or more processing devices to cause a video processing device to: receive a first palette entry for palette encoding a target coding unit (CU), determine whether the target CU is part of a single-tree slice, determine whether the target CU is encoded with separate luma and chroma trees, and, in response to determining that the target CU is part of a single-tree slice and is encoded with separate luma and chroma trees, decode a first component of the target CU based on the first palette entry and decode a second component of the target CU based on a default palette entry.

[0007] BRIEF DESCRIPTION OF THE DRAWINGS

[0007] Embodiments and various aspects of the present disclosure are illustrated in the following detailed description and the accompanying drawings, in which various features are not drawn to scale. [Brief explanation of the drawings]

[0008] [Figure 1]

[0008] FIG. 1 is a schematic diagram illustrating the structure of an example video sequence, according to some embodiments of the present disclosure. [Figure 2]

[0009] 1 shows a schematic diagram of an example encoder in a hybrid video coding system, according to some embodiments of the present disclosure. [Figure 3]

[0010] 1 shows a schematic diagram of an exemplary decoder in a hybrid video coding system, according to some embodiments of the present disclosure. [Figure 4]

[0011] 1 shows a block diagram of an exemplary device for encoding or decoding video, according to some embodiments of the present disclosure. [Figure 5]

[0012] 1 shows a schematic diagram of an exemplary image block coded in palette mode, according to some embodiments of the present disclosure. [Figure 6]

[0013] 1 shows a schematic diagram of an example process for updating a palette predictor after encoding a coding unit, according to some embodiments of the present disclosure. [Figure 7]

[0014] 1 shows exemplary Table 1 illustrating a portion of a Sequence Parameter Set (SPS) syntax table, according to some embodiments of the present disclosure. [Figure 8]

[0015] 1 shows exemplary Table 2 illustrating a portion of a coding unit syntax table according to some embodiments of the present disclosure. [Figure 9A]

[0016] 1 shows exemplary Table 3 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 9B]

[0016] Figure 3 shows an exemplary Table 3 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 10A]

[0017] 1 illustrates an exemplary decoding process for palette mode, according to some embodiments of the present disclosure. [Figure 10B] 1 illustrates an exemplary decoding process for palette mode, according to some embodiments of the present disclosure. [Figure 11]

[0018] 10 shows exemplary Table 4 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 12A]

[0019] 1 illustrates exemplary palette encoding semantics and decoding processes for a palette mode, according to some embodiments of the present disclosure. [Figure 12B] 1 illustrates exemplary palette encoding semantics and decoding processes for palette mode, according to some embodiments of the present disclosure. [Figure 13]

[0020] 10 shows exemplary Table 5 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 14]

[0021] 1 illustrates an exemplary decoding process for palette mode, according to some embodiments of the present disclosure. [Figure 15]

[0022] 10 shows exemplary Table 6 illustrating a portion of a coding unit syntax table according to some embodiments of the present disclosure. [Figure 16]

[0023] 10 shows exemplary Table 7 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 17A]

[0024] 10 illustrates another example palette encoding semantics and decoding process for a palette mode, according to some embodiments of the present disclosure. [Figure 17B]

[0024] Figure 6 illustrates another exemplary palette encoding semantics and decoding process for palette mode, according to some embodiments of the present disclosure. [Figure 18]

[0025] 1 shows a flowchart of an exemplary video processing method according to some embodiments of the present disclosure. [Figure 19]

[0026] 10 shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure. [Figure 20]

[0027] 10 shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure. [Figure 21]

[0028] 10 shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure. [Figure 22]

[0029] 10 shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure. [Figure 23]

[0030] 10 shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0009] Detailed Description

[0031] Reference will now be made in detail to exemplary embodiments, examples of which are illustrated in the accompanying drawings. The following description will refer to the accompanying drawings, in which like numbers in different drawings represent the same or similar elements unless otherwise stated. The implementations set forth in the following description of exemplary embodiments do not represent all implementations consistent with the present invention. Instead, they are merely examples of apparatus and methods consistent with aspects related to the present invention as set forth in the appended claims. Certain aspects of the present disclosure are described in more detail below. In the event of a conflict with incorporated terms and / or definitions, the terms and definitions provided herein will control.

[0010]

[0032] The ITU-T Video Coding Expert Group (VCEG) and the ISO / IEC Moving Picture Expert Group (MPEG) Joint Video Experts Team (JVET) are currently developing the Versatile Video Coding (VVC) / H.266 standard. The VVC standard aims to double the compression efficiency of its predecessor, the High Efficiency Video Coding (HEVC) / H.265 standard. In other words, the goal of VVC is to achieve the same subjective quality as HEVC / H.265 but with half the bandwidth.

[0011]

[0033] To achieve the same subjective quality as HEVC / H.265 at half the bandwidth, JVET has been developing technology that exceeds HEVC using the JEM (joint exploration model) reference software. Since the coding technology was incorporated into JEM, JEM achieved significantly higher coding performance than HEVC. VCEG and MPEG have officially begun work on the next generation video compression standard that will surpass HEVC.

[0012]

[0034] The VVC standard is a recent development and continues to add more coding techniques that provide better compression performance. VVC is based on the same hybrid video coding system that has been used in modern video compression standards such as HEVC, H.264 / AVC, MPEG2, and H.263.

[0013]

[0035] A video is a set of static pictures (or "frames") arranged in time sequence to store visual information. A video capture device (e.g., a camera) can be used to capture and store these pictures in time sequence, and a video playback device (e.g., a television, a computer, a smartphone, a tablet computer, a video player, or any end-user terminal with display capabilities) can be used to display such pictures in time sequence. In some applications, a video capture device can also transmit the captured video in real time to a video playback device (e.g., a computer with a monitor) for purposes such as supervision, conferencing, or live broadcasting.

[0014]

[0036] To reduce the storage space and transmission bandwidth required for such applications, video may be compressed before storage and transmission and decompressed before display. Compression and decompression may be performed by software executed by a processor (e.g., a general-purpose computer processor) or dedicated hardware. The compression module is commonly referred to as an "encoder," and the decompression module is commonly referred to as a "decoder." Encoders and decoders may be collectively referred to as a "codec." The encoders and decoders may be implemented as any of a variety of suitable hardware, software, or combinations thereof. For example, hardware implementations of encoders and decoders may include circuitry such as one or more microprocessors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), discrete logic, or any combination thereof. Software implementations of encoders and decoders may include program code, computer-executable instructions, firmware, or any suitable computer-implemented algorithm or process fixed on a computer-readable medium. Video compression and decompression may be performed by various algorithms or standards, such as MPEG-1, MPEG-2, MPEG-4, and the H.26x family. In some applications, a codec can reconstruct video from a first encoding standard and recompress the reconstructed video using a second encoding standard, in which case the codec is sometimes called a "transcoder."

[0015]

[0037] A video encoding process can identify and retain useful information that can be used for picture reconstruction and ignore information that is not important for reconstruction. If the ignored, unimportant information cannot be perfectly reconstructed, such an encoding process may be called "lossy." Otherwise, it may be called "lossless." Most encoding processes are lossy; this is a tradeoff to reduce the required storage space and transmission bandwidth.

[0016]

[0038] Useful information about a picture being encoded (called the "current picture") includes changes relative to a reference picture (e.g., a previously encoded and reconstructed picture). Such changes may include pixel position changes, luminance changes, or color changes, among which position changes are the most important. Position changes of pixels representing an object may reflect the object's motion between the reference picture and the current picture.

[0017]

[0039] A picture that is coded without referencing another picture (i.e., it is its own reference picture) is called an "I-picture." A picture that is coded using a previous picture as a reference picture is called a "P-picture." A picture that is coded using both a previous picture and a future picture as a reference picture (i.e., the referencing is "bidirectional") is called a "B-picture."

[0018]

[0040] 1 illustrates the structure of an example video sequence 100 according to some embodiments of the present disclosure. The video sequence 100 may be live video or captured and archived video. The video 100 may be real video, computer-generated video (e.g., computer game video), or a combination thereof (e.g., real video with augmented reality effects). The video sequence 100 may be input from a video capture device (e.g., a camera), a video archive containing previously captured video (e.g., video files saved on a storage device), or a video feed interface (e.g., a video broadcast transceiver) for receiving video from a video content provider.

[0019]

[0041] As shown in FIG. 1, video sequence 100 may include a series of pictures arranged temporally along a timeline including pictures 102, 104, 106, and 108. Pictures 102-106 are consecutive, with more pictures between pictures 106 and 108. In FIG. 1, picture 102 is an I-picture and its reference picture is picture 102 itself. Picture 104 is a P-picture and its reference picture is picture 102, as indicated by the arrow. Picture 106 is a B-picture and its reference pictures are pictures 104 and 108, as indicated by the arrows. In some embodiments, the reference picture for a picture (e.g., picture 104) may not be immediately preceding or following that picture. For example, the reference picture for picture 104 may be a picture preceding picture 102. It should be noted that the reference pictures of pictures 102-106 are merely examples, and this disclosure does not limit the reference picture embodiment to the example shown in FIG.

[0020]

[0042] Typically, video codecs do not encode or decode an entire picture at once due to the computational complexity of such a task. Rather, they may divide a picture into basic segments and encode or decode the picture segment by segment. Such basic segments are referred to as basic processing units ("BPUs") in this disclosure. For example, structure 110 in FIG. 1 illustrates an example structure for a picture (e.g., any of pictures 102-108) in video sequence 100. In structure 110, the picture is divided into 4x4 basic processing units, the boundaries of which are indicated by dashed lines. In some embodiments, a basic processing unit may be referred to as a "macroblock" in some video coding standards (e.g., the MPEG family, H.261, H.263, or H.264 / AVC) or a "coding tree unit" (CTU) in some other video coding standards (e.g., H.265 / HEVC or H.266 / VVC). The basic processing unit may have a variable size of picture, such as 128x128, 64x64, 32x32, 16x16, 4x8, 16x32, or any shape and size of pixels. The size and shape of the basic processing unit may be selected for each picture based on a balance between coding efficiency and the level of detail to be maintained in the basic processing unit.

[0021]

[0043] A basic processing unit may be a logical unit that may include a collection of different types of video data stored in computer memory (e.g., in a video frame buffer). For example, a basic processing unit for a color picture may include a luma component (Y) representing achromatic lightness information, one or more chroma components (e.g., Cb and Cr) representing color information, and related syntax elements (where the luma and chroma components may have the same size basic processing unit). The luma and chroma components are sometimes referred to as "coding tree blocks" (CTBs) in some video coding standards (e.g., H.265 / HEVC or H.266 / VVC). Any operation performed on a basic processing unit can be repeated for each of its luma and chroma components.

[0022]

[0044] Video coding has multiple stages of operation, examples of which are shown in Figures 2 and 3. At each stage, the size of the basic processing unit may still be too large for processing and therefore may be further divided into segments referred to as "basic processing subunits" in this disclosure. In some embodiments, the basic processing subunits may be referred to as "blocks" in some video coding standards (e.g., MPEG family, H.261, H.263, or H.264 / AVC) or as "coding units" (CUs) in some other video coding standards (e.g., H.265 / HEVC or H.266 / VVC). The basic processing subunits may have the same or smaller size as the basic processing units. Similar to basic processing units, basic processing subunits are also logical units that may contain a collection of different types of video data (e.g., Y, Cb, Cr, and related syntax elements) stored in computer memory (e.g., in a video frame buffer). Any operation performed on a basic processing sub-unit can be repeated for each of its luma and chroma components. Note that such division can be performed to further levels depending on the processing needs. Note also that different stages can use different schemes to divide the basic processing units.

[0023]

[0045] For example, in a mode decision stage (an example of which is shown in FIG. 2), an encoder may decide which prediction mode (e.g., intra-picture prediction or inter-picture prediction) to use for a basic processing unit, which may be too large to make such a decision. The encoder may divide the basic processing unit into multiple basic processing sub-units (e.g., CUs in the case of H.265 / HEVC or H.266 / VVC) and determine the prediction type for each individual basic processing sub-unit.

[0024]

[0046] As another example, in the prediction stage (an example of which is shown in FIG. 2), the encoder can perform prediction operations at the level of basic processing subunits (e.g., CUs). However, in some cases, the basic processing subunits may still be too large to process. The encoder can further divide the basic processing subunits into smaller segments (e.g., called "prediction blocks" or "PBs" in H.265 / HEVC or H.266 / VVC), and perform prediction operations at the level of the segments.

[0025]

[0047] As another example, in the transform stage (an example of which is shown in FIG. 2), the encoder can perform transform operations on residual basic processing subunits (e.g., CUs). However, in some cases, the basic processing subunits may still be too large to process. The encoder can further divide the basic processing subunits into smaller segments (e.g., called "transform blocks" or "TBs" in H.265 / HEVC or H.266 / VVC), and perform transform operations at the segment level. Note that the division scheme of the same basic processing subunit may be different in the prediction stage and the transform stage. For example, in H.265 / HEVC or H.266 / VVC, the prediction blocks and transform blocks of the same CU may have different sizes and numbers.

[0026]

[0048] 1, the basic processing unit 112 is further divided into 3x3 basic processing sub-units, the boundaries of which are indicated by dotted lines. Different basic processing units of the same picture may be divided into basic processing sub-units in different schemes.

[0027]

[0049] In some implementations, to provide parallel processing capabilities and error resilience for video encoding and decoding, a picture may be divided into multiple regions for processing, such that for each region of a picture, the encoding or decoding process can be independent of information from any other region of the picture. That is, each region of a picture can be processed independently. In this way, a codec can process different regions of a picture in parallel, thus improving coding efficiency. Also, if data for one region is corrupted during processing or lost during network transmission, the codec can accurately encode or decode other regions of the same picture without relying on the corrupted or lost data, thus providing error resilience. In some video coding standards, a picture may be divided into different types of regions. For example, H.265 / HEVC and H.266 / VVC provide two region types: "slice" and "tile." It should also be noted that different pictures in video sequence 100 may have different partitioning schemes for dividing the picture into regions.

[0028]

[0050] 1, structure 110 is divided into three regions 114, 116, and 118, the boundaries of which are shown as solid lines within structure 110. Region 114 includes four basic processing units. Regions 116 and 118 each include six basic processing units. It should be noted that the basic processing units, basic processing subunits, and regions of structure 110 in FIG. 1 are merely examples, and the present disclosure does not limit the embodiments thereof.

[0029]

[0051] 2 shows a schematic diagram of an example encoder 200 in a hybrid video coding system according to some embodiments of this disclosure. The video encoder 200 may perform intra- or inter-coding of blocks within video frames, including video blocks or partitions or sub-partitions of video blocks. Intra-coding may utilize spatial prediction to reduce or remove spatial redundancy in video within a given video frame. Inter-coding may utilize temporal prediction to reduce or remove temporal redundancy in video within adjacent frames of a video sequence. Intra-mode may refer to several spatial-based compression modes. Inter-mode (e.g., unidirectional prediction or bidirectional prediction) may refer to several temporal-based compression methods.

[0030]

[0052] Referring to FIG. 2, an input video signal 202 may be processed block by block. For example, a video block unit may be a 16x16 pixel block (e.g., a macroblock (MB)). The size of the video block unit may vary depending on the encoding technique used and the required accuracy and efficiency. In HEVC, for example, to compress video signals with resolutions of 1080p or higher, an extended block size (e.g., a coding tree unit (CTU)) may be used. In HEVC, a CTU may contain up to 64x64 luma samples, corresponding chroma samples, and related syntax elements. In VVC, the size of the CTU may be further increased to contain 128x128 luma samples, corresponding chroma samples, and related syntax elements. The CTU may be further divided into coding units (CUs), for example, using a quad tree, a binary tree, or a ternary tree. The CUs may be further divided into prediction units (PUs), to which different prediction methods may be applied. Each input video block may be processed using a spatial prediction unit 260 or a temporal prediction unit 262.

[0031]

[0053] Spatial prediction unit 260 performs spatial prediction (e.g., intra prediction) on the current block / CU using information about the same picture / slice that contains the current block. Spatial prediction may use pixels of already-encoded neighboring blocks in the same video picture frame / slice to predict the current video block. Spatial prediction may reduce spatial redundancy inherent in video signals.

[0032]

[0054] Temporal prediction unit 262 performs temporal prediction (e.g., inter-prediction) on the current block using information from a picture / slice different from the picture / slice containing the current block. Temporal prediction for a video block may be signaled by one or more motion vectors. In unidirectional temporal prediction, only one motion vector pointing to one reference picture is used to generate a prediction signal for the current block. In bidirectional temporal prediction, on the other hand, two motion vectors, each pointing to a respective reference picture, may be used to generate a prediction signal for the current block. A motion vector may indicate the amount and direction of motion between the current block and one or more associated blocks in a reference frame. If multiple reference pictures are supported, one or more reference picture indexes may be transmitted for the video block. The one or more reference indexes may be used to identify which reference picture in a reference picture store or decoded picture buffer (DPB) 264 the temporal prediction signal may come from.

[0033]

[0055] A mode decision and encoder control unit 280 in the encoder may select a prediction mode based on, for example, rate-distortion optimization. A prediction block may be obtained based on the determined prediction mode. The prediction block may be subtracted from the current video block in summer 216. A prediction residual may be transformed by transform unit 204 and quantized by quantization unit 206. The quantized residual coefficients may be inverse quantized in inverse quantization unit 210 and inverse transformed in inverse transform unit 212 to form a reconstructed residual. The reconstructed residual may be added to the prediction block in summer 226 to form a reconstructed video block. The reconstructed video block before loop filtering may be used to provide reference samples for intra prediction.

[0034]

[0056] The reconstructed video blocks may be subjected to loop filtering in loop filter 266. Loop filtering such as a deblocking filter, sample adaptive offset (SAO), and adaptive loop filter (ALF) may be applied. The reconstructed blocks after loop filtering may be stored in reference picture store 264 and used to provide inter-prediction reference samples for encoding other video blocks. To form output video bitstream 220, the coding mode (e.g., inter or intra), prediction mode information, motion information, and quantized residual coefficients may be sent to entropy coding unit 208 to further reduce the bit rate before the data is compressed and packed to form bitstream 220.

[0035]

[0057] 3 shows a schematic diagram of an example decoder 300 in a hybrid video coding system according to some embodiments of this disclosure. Referring to FIG. 3, a video bitstream 302 may be unpacked or entropy decoded in an entropy decoding unit 308. Coding mode information may be used to determine whether to select a spatial prediction unit 360 or a temporal prediction unit 362. The prediction mode information may be sent to a corresponding prediction unit to generate a prediction block. For example, motion compensation prediction may be applied by the temporal prediction unit 362 to form a temporal prediction block.

[0036]

[0058] The residual coefficients may be sent to the inverse quantization unit 310 and the inverse transform unit 312 to obtain a reconstructed residual. The prediction block and the reconstructed residual may be summed at 326 to form a reconstructed block before loop filtering. The reconstructed block may then be loop filtered at the loop filter 366. Loop filtering such as a deblocking filter, SAO, and ALF may be applied. The reconstructed block after loop filtering may be stored in a reference picture store 364. The reconstructed data in the reference picture store 364 may be used to obtain a decoded video 320 or to predict future video blocks. The decoded video 320 may be displayed on a display device such as a TV, PC, smartphone, or tablet for viewing by an end user.

[0037]

[0059] FIG. 4 is a block diagram of an exemplary device 400 for encoding or decoding video, according to some embodiments of the present disclosure. As shown in FIG. 4, the device 400 may include a processor 402. When the processor 402 executes the instructions described herein, the device 400 can become a dedicated machine for video encoding or decoding. The processor 402 may be any type of circuitry capable of manipulating or processing information. For example, the processor 402 may include any combination of several central processing units (i.e., "CPUs"), graphics processing units (i.e., "GPUs"), neural processing units ("NPUs"), microcontroller units ("MCUs"), optical processors, programmable logic controllers, microcontrollers, microprocessors, digital signal processors, intellectual property (IP) cores, programmable logic arrays (PLAs), programmable array logic (PALs), general-purpose array logic (GALs), complex programmable logic devices (CPLDs), field programmable gate arrays (FPGAs), systems-on-chips (SoCs), or application-specific integrated circuits (ASICs), etc. In some embodiments, processor 402 may be a set of processors grouped as a single logical component. For example, as shown in FIG. 4, processor 402 may include multiple processors, including processor 402a, processor 402b, and processor 402n.

[0038]

[0060] The device 400 may also include memory 404 configured to store data (e.g., an instruction set, computer code, intermediate data, etc.). For example, as shown in FIG. 4, the stored data may include program instructions (e.g., program instructions for implementing the stages of FIG. 2 or FIG. 3) and data for processing. The processor 402 may access the program instructions and data for processing (e.g., via bus 410) and execute the program instructions to perform operations or manipulations on the data for processing. The memory 404 may include a high-speed random access storage device or a non-volatile storage device. In some embodiments, the memory 404 may include any combination of random access memory (RAM), read-only memory (ROM), optical disks, magnetic disks, hard drives, solid-state drives, flash drives, security digital (SD) cards, memory sticks, CompactFlash (CF) cards, etc. The memory 404 may also be a collection of memories (not shown in FIG. 4) grouped as a single logical component.

[0039]

[0061] Bus 410 may be a communication device that transfers data between components within apparatus 400, such as an internal bus (e.g., a CPU memory bus) or an external bus (e.g., a Universal Serial Bus port, a Peripheral Component Interconnect Express port).

[0040]

[0062] For the sake of clarity and simplicity, in this disclosure, the processor 402 and other data processing circuitry will be collectively referred to as "data processing circuitry." The data processing circuitry may be implemented entirely as hardware, or as a combination of software, hardware, or firmware. Furthermore, the data processing circuitry may be a single, independent module, or may be fully or partially integrated with any other components of the device 400.

[0041]

[0063] The device 400 may further include a network interface 406 to provide wired or wireless communication with a network (e.g., the Internet, an intranet, a local area network, or a mobile communications network, etc.) In some embodiments, the network interface 406 may include any combination of several network interface controllers (NICs), radio frequency (RF) modules, transponders, transceivers, modems, routers, gateways, wired network adapters, wireless network adapters, Bluetooth adapters, infrared adapters, near field communication ("NFC") adapters, cellular network chips, etc.

[0042]

[0064] In some embodiments, apparatus 400 may optionally further include a peripheral interface 408 to provide connection to one or more peripheral devices. As shown in Figure 4, the peripheral devices may include, but are not limited to, a cursor control device (e.g., a mouse, a touchpad, or a touchscreen), a keyboard, a display (e.g., a cathode ray tube display, a liquid crystal display, or a light emitting diode display), or a video input device (e.g., a camera, or an input interface coupled to a video archive), etc.

[0043]

[0065] It should be noted that the video codec may be implemented as any combination of software or hardware modules within the device 400. For example, some or all of the stages of the encoder 200 of Figure 2 or the decoder 300 of Figure 3 may be implemented as one or more software modules of the device 400, such as program instructions that may be loaded into the memory 404. As another example, some or all of the stages of the encoder 200 of Figure 2 or the decoder 300 of Figure 3 may be implemented as one or more hardware modules of the device 400, such as dedicated data processing circuits (e.g., FPGAs, ASICs, or NPUs).

[0044]

[0066] In the quantization and inverse quantization functional blocks (e.g., quantization unit 206 and inverse quantization unit 210 in FIG. 2 and inverse quantization unit 310 in FIG. 3), a quantization parameter (QP) is used to determine the amount of quantization (and inverse quantization) applied to the prediction residual. The initial QP value used for coding a picture or slice can be signaled at a high level, for example, using the init_qp_minus26 syntax element in the picture parameter set (PPS) and the slice_qp_delta syntax element in the slice header. Furthermore, the QP value can be adapted at a local level per CU using a delta QP value sent at the granularity of a quantization group.

[0045]

[0067] In VVC (e.g., VVC Draft 7), palette mode is used in 4:4:4 color format. When palette mode is enabled, if the size of the CU is 64x64 or less, a flag indicating whether palette mode is used is transmitted at the CU level.

[0046]

[0068] FIG. 5 shows a schematic diagram of an example image block 500 coded in palette mode according to some embodiments of the present disclosure. As shown in FIG. 5, when palette mode is used to code a current CU, sample values ​​at each location within the CU are represented by a small set of representative color values. This set is called a palette (e.g., palette 510). For sample locations (e.g., locations 501, 502, or 503) that have values ​​close to colors in the palette, a corresponding palette index (e.g., index 0, index 1, index 2, or index 3) is signaled. According to some disclosed embodiments, color values ​​outside the palette can be specified by signaling an escape index (or escape color index). Then, for all locations within the CU (e.g., location 504) that use an escape color index (e.g., index 4), the (quantized) color component values ​​are signaled for each of those locations.

[0047]

[0069] To encode the palette, a palette predictor is maintained. The predictor is initialized to 0 (e.g., empty) at the beginning of each slice in the non-wavefront case and at the beginning of each CTU row in the wavefront case. FIG. 6 shows a schematic diagram of an example process 600 for updating the palette predictor after encoding a coding unit according to some embodiments of the present disclosure. As shown in FIG. 6, for each entry in the palette predictor, a reuse flag is signaled to indicate whether the entry is included in the current palette of the current CU. The reuse flag is transmitted using run-length coding of zeros, followed by the number of new palette entries and the component values ​​of the new palette entries. After encoding a palette-encoded CU, the palette predictor is updated using the current palette, and entries from the previous palette predictor that are not reused in the current palette are added to the end of the new palette predictor until it reaches the maximum allowed size.

[0048]

[0070] In some embodiments, an escape flag is signaled for each CU to indicate whether an escape symbol is present in the current CU. If an escape symbol is present, the palette table is incremented by 1 and the last index (e.g., index 4 shown in Figure 5) is assigned to be the escape symbol.

[0049]

[0071] Referring again to Figure 5, the palette indices of the samples in a CU (e.g., index 0, index 1, index 2, index 3, and index 4) form a palette index map. The index map is coded using a horizontal or vertical traverse scan. The scan order is explicitly signaled in the bitstream using the palette_transpose_flag syntax element. The palette index map is coded using index-run mode or index copy mode.

[0050]

[0072] In some embodiments, palette mode is only allowed for 4:4:4 color formats. However, a large amount of video content may be encoded in other color formats, such as 4:2:0 chroma subsampling formats. This disclosure provides methods for extending palette mode to other chroma formats, such as monochrome, 4:2:0, and 4:2:2.

[0051]

[0073] Furthermore, in slices with dual luma / chroma trees, palettes are applied separately to the luma (Y component) and chroma (Cb and Cr components). In single-tree slices, palettes are applied jointly to the Y, Cb, and Cr components (e.g., each entry in the palette contains Y, Cb, and Cr values). However, in VVC, for 4:2:0 and 4:2:2 color formats, due to constraints on the minimum allowable chroma coding block size, coding units (CUs) of a single-tree slice may have separate luma and chroma trees. Therefore, a joint palette cannot be applied to a dual-tree CU (even if the CU belongs to a single-tree slice) because the luma and chroma of the dual-tree CU are processed separately. Therefore, some embodiments of the present disclosure can address the possibility of a single-tree slice with a local dual-tree structure (e.g., single-tree at the slice level but dual-tree at the CU level) while extending palette mode to other chroma formats such as 4:2:0 and 4:2:2.

[0052]

[0074] Some embodiments of the present disclosure provide methods and devices for applying a palette mode to a color format other than 4:4:4 color format (or a non-4:4:4 color format) and a single tree slice having a local dual tree structure.

[0053]

[0075] Some embodiments of the present disclosure may allow palette mode for all chroma formats, such as monochrome, 4:2:0, 4:2:2, 4:4:4, etc. FIG. 7 shows example Table 1 illustrating a portion of an SPS syntax table, according to some embodiments of the present disclosure. As shown in Table 1, syntax elements shown in strikethrough in box 701 are proposed to be deleted from the current VVC Draft 7, and syntax elements shown in italics in box 702 are proposed to be added to the current VVC Draft 7. The SPS flag sps_palette_enabled_flag can be signaled regardless of the value of the chroma_format_idc syntax element.

[0054]

[0076] As explained above, in current video coding standards (e.g., VVC Draft 7), palette mode is applied to the Y, Cb, and Cr components jointly in slices with a single tree. P and B slices are always coded as single-tree slices. The tree structure of an I-slice is signaled in the SPS syntax, for example, by the qtbtt_dual_tree_intra_flag syntax element. A qtbtt_dual_tree_intra_flag syntax element equal to 1 specifies that two separate coding_tree syntax structures for luma and chroma are used for an I-slice. A qtbtt_dual_tree_intra_flag syntax element equal to 0 specifies that no separate coding_tree syntax structure is used for an I-slice.

[0055]

[0077] For non-inter smallest chroma intra prediction units (SCIPUs), further division of chroma is not allowed but further division of luma is allowed, so a coding unit of a single-tree slice can have separate luma and chroma trees. In single-tree coding, an SCIPU is defined as a coding tree node whose chroma block size is equal to or greater than 16 chroma samples and has at least one child luma block with less than 64 luma samples. Therefore, a joint palette cannot be applied to a dual-tree CU (even if the dual-tree CU belongs to a single-tree slice) because the luma and chroma of the dual-tree CU are processed separately. This poses a problem for applying palette mode to a single-tree slice with a dual-tree CU. The present disclosure provides several embodiments to address this issue.

[0056]

[0078] According to some embodiments, palette mode is not allowed for a CU if the CU includes a local dual tree. Thus, palette mode is not allowed for a CU if both of the following conditions are met: (1) the CU is coded by separate trees, and (2) the CU belongs to a slice with a single tree. FIG. 8 shows exemplary Table 2, which illustrates a portion of a coding unit syntax table, according to some embodiments of the present disclosure. The coding unit syntax table of Table 2 may not allow palette mode for a CU. As shown in Table 2, syntax changes consistent with the present disclosure are italicized in box 801. Based on the coding unit syntax table of Table 2, palette mode is not allowed if the following two conditions are met: (treeType ! = SINGLE_TREE) && (slice_type ! = I || qtbtt_dual_tree_intra_flag == 0)

[0057]

[0079] According to some embodiments, to improve the coding efficiency of the palette mode, the palette mode is applied to a CU that includes a local dual tree. In the local dual tree block, a reuse flag (e.g., the palette_predictor_run syntax element) is signaled without adding a new palette entry (e.g., the new_palette_entries[ cIdx ][ i ] syntax element). Because the local dual tree block can only contain luma (or chroma) components, the chroma (or luma) value of the new palette entry may be empty. Therefore, sending a new palette entry for the local dual tree block is restricted. Figure 9 shows an example Table 3 illustrating a portion of a palette coding syntax table according to some embodiments of the present disclosure. The palette coding syntax table of Table 3 allows the palette mode to be applied to a CU that includes a local dual tree. As shown in Table 3, syntax changes consistent with embodiments of the present invention are italicized in boxes 901-904.

[0058]

[0080] Furthermore, in non-4:4:4 color formats, there are pixels that contain only luma components, and therefore in some embodiments, when encoded using escape mode, only the luma values ​​are signaled for these pixels (see syntax in Table 3 of Figure 9, both bold and shaded in box 903).

[0059]

[0081] 10 shows an example decoding process for palette mode according to some embodiments of this disclosure. The decoding process includes section 8.4.5.3 in VVC Draft 7. The decoding process may include two processes: one process for reconstructing pixels and another process for updating the palette predictor.

[0060]

[0082] As shown in Figure 10, the decoding process may be similar to Section 8.4.5.3 in VVC Draft 7. The decoding process may include some syntax changes, shown in italics in boxes 1001-1003. When updating a palette predictor using the current palette, entries for the current palette are placed before the new palette predictor. Then, entries from previous palette predictors that are not reused in the current palette are added to the end of the new palette predictor. In local dual tree blocks, each palette entry contains both luma and chroma components. Therefore, the palette predictor update process involves all three components. It is a bitstream conformance requirement that the value of PredictorPaletteSize[startComp] be in the range of 0 to 63.

[0061]

[0083] According to some embodiments, a palette mode can be applied to a local dual tree block in the same way as a palette mode applied to a single tree block. Since a local dual tree block can only contain luma (or chroma) components, the value of the luma (or chroma) component can be signaled, and a default value can be set for the chroma (or luma) component for a new palette entry. As an example, the default value can be related to the bit depth of the video sequence. As another example, the default value can be zero.

[0062]

[0084] Furthermore, for non-4:4:4 color formats, when encoded using escape mode, only luma values ​​are signaled for pixels that contain only luma components. Figure 11 shows exemplary Table 4, which illustrates a portion of a palette encoding syntax table, in accordance with some embodiments of the present disclosure. The palette encoding syntax table of Table 4 can apply palette mode to CUs that contain local dual trees. As shown in Table 4, syntax changes consistent with embodiments of the present invention are italicized in boxes 1101 and 1102.

[0063]

[0085] In some embodiments of the present disclosure, the syntax parse for the local dual tree may be aligned with the syntax parse for the single tree, and furthermore, the coding efficiency of the palette mode may be improved since fewer bits are signaled.

[0064]

[0086] Figure 12 illustrates an example palette encoding semantics and decoding process for palette mode, according to some embodiments of the present disclosure. As shown in Figure 12, proposed syntax changes to Section 7.4.12.6 and Section 8.4.5.3 in VVC Draft 7 are italicized in boxes 1201-1205. In the local dual tree block, when updating the palette predictor, default values ​​are first filled in the current palette (see the bold semantics in Figure 12). Then, all three components are involved in the palette predictor update process. It is a bitstream conformance requirement that the value of PredictorPaletteSize[startComp] be in the range of 0 to 63.

[0065]

[0087] According to some embodiments, the palette mode can be applied to the local dual tree block in the same manner as the palette mode applied to the single tree block, similar to the embodiment shown in Table 4 of Figure 11. However, in some embodiments, the palette for the local dual tree block is not used to update the palette predictor. Therefore, the reordering process of the palette predictor is skipped, which can simplify the decoding process.

[0066]

[0088] Furthermore, for non-4:4:4 color formats, when encoded using escape mode, only luma values ​​are signaled for pixels that contain only luma components. Figure 13 shows exemplary Table 5, which illustrates a portion of a palette encoding syntax table, in accordance with some embodiments of this disclosure. The palette encoding syntax table of Table 5 can apply palette mode to CUs that contain local dual trees. As shown in Table 5, syntax changes consistent with embodiments of the present invention are italicized in boxes 1301 and 1302.

[0067]

[0089] Figure 14 shows an example decoding process for palette mode, according to some embodiments of the present disclosure. As shown in Figure 14, the proposed syntax changes to section 8.4.5.3 in VVC Draft 7 are italicized in boxes 1401 and 1402. The palette predictor is not updated in the local dual tree block. It is a bitstream conformance requirement that the value of PredictorPaletteSize[startComp] be in the range of 0 to 63.

[0068]

[0090] According to some embodiments, a palette mode can be applied to a local dual tree luma block in the same way as a palette mode applied to a single tree block. Palette mode is disabled for a local dual tree chroma block. Since a local dual tree luma block can only contain luma components, the value of the luma component is signaled and default values ​​can be set for the chroma components for new palette entries. As an example, the default value can be related to the bit depth of the video sequence. As another example, the default value can be zero.

[0069]

[0091] Furthermore, for non-4:4:4 color formats, when encoded using escape mode, only luma values ​​are signaled for pixels that contain only luma components. Figure 15 shows example Table 6, which illustrates a portion of a coding unit syntax table, in accordance with some embodiments of this disclosure. Figure 16 shows example Table 7, which illustrates a portion of a palette encoding syntax table, in accordance with some embodiments of this disclosure. The palette encoding syntax table can apply palette mode to CUs that contain luma local dual trees. Syntax modifications to Tables 6 and 7 consistent with embodiments of the present invention are shown in italics in box 1501 and boxes 1601-1602, respectively.

[0070]

[0092] In some embodiments of the present disclosure, palette design can be simplified by disabling the palette for the chroma local dual tree.

[0071]

[0093] Figure 17 illustrates an example palette encoding semantics and decoding process for palette mode, according to some embodiments of the present disclosure. As shown in Figure 17, proposed syntax changes to Section 7.4.12.6 and Section 8.4.5.3 in VVC Draft 7 are italicized in boxes 1701-1705. In the local dual tree block, when performing a palette predictor update, default values ​​are first filled in the current palette. Then, all three components are involved in the palette predictor update process. It is a bitstream conformance requirement that the value of PredictorPaletteSize[startComp] be in the range of 0 to 63.

[0072]

[0094] 18 shows a flowchart of an exemplary video processing method 1800 according to some embodiments of the present disclosure. In some embodiments, method 1800 may be performed by one or more software or hardware components of a decoder (e.g., decoder 300 of FIG. 3) or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 1800. In some embodiments, method 1800 may be implemented by a computer program product embodied in a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0073]

[0095] In step 1801, a palette entry for palette encoding a target CU may be received. For example, a decoder (e.g., decoder 300 of FIG. 3) may receive a bitstream including one or more palette entries (e.g., new_palette_entries[cIdx][i] in Table 3 of FIG. 9) for palette encoding a target CU.

[0074]

[0096] In step 1803, it may be determined whether the target CU is coded with separate luma and chroma trees. For example, this determination may be made based on whether a condition (treeType ! = SINGLE_TREE) is met. If treeType ! = SINGLE_TREE, it may be determined that the target CU is coded with separate luma and chroma trees.

[0075]

[0097] At step 1805, it may be determined whether the target CU is part of a single-tree slice. In some embodiments, method 1800 may include determining whether the target CU is part of a P slice or a B slice (e.g., slice_type !=1), or determining whether the target CU is part of a single-tree I slice (e.g., qtbtt_dual_tree_intra_flag == 0).

[0076]

[0098] At step 1807, in response to determining that the target CU (a) is encoded with separate luma and chroma trees and (b) is part of a single-tree slice, a first component of the target CU may be decoded based on the received palette entry, and a second component of the target CU may be decoded based on a default palette entry. In some embodiments, method 1800 may include, in response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding the first component and the second component of the target CU based on the received palette entry. The first component is a luma component and the second component is a chroma component, or the first component is a chroma component and the second component is a luma component.

[0077]

[0099] In some embodiments, method 1800 may include receiving a reuse flag to reuse palette entries to palette encode the target CU, and updating a palette predictor of the target CU based on the received palette entries and the received reuse flag. In some embodiments, a size of the palette predictor of the target CU is in the range of 0 to 63. In some embodiments, method 1800 may include updating the palette predictor of the target CU based on the received palette entries. In some embodiments, the palette predictor of the target CU is not updated after decoding the first component and the second component.

[0078]

[0100] 19 shows a flowchart of an exemplary video processing method 1900 according to some embodiments of the present disclosure. In some embodiments, method 1900 may be performed by one or more software or hardware components of an encoder (e.g., encoder 200 of FIG. 2), a decoder (e.g., decoder 300 of FIG. 3), or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 1900. In some embodiments, method 1900 may be implemented by a computer program product embodied on a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0079]

[0101] In step 1901, the method 1900 may include signaling a flag indicating that palette mode is enabled for the target CU. The flag may be signaled regardless of whether a chroma sampling format is used for the target CU. In some embodiments, the flag is signaled within an SPS. The chroma sampling format may include one or more of a 4:4:4 format, a 4:2:2 format, or a 4:2:0 format.

[0080]

[0102] At step 1903, method 1900 may also include determining a chroma sampling format (e.g., 4:4:4 format, 4:2:2 format, or 4:2:0 format) used for the target CU. In some embodiments, method 1900 may include signaling a corresponding syntax element (e.g., the sps_act_enabled_flag syntax element in Table 1 of FIG. 7) based on the determined chroma sampling format (e.g., 4:4:4 format).

[0081]

[0103] 20 shows a flowchart of an exemplary video processing method 2000 according to some embodiments of the present disclosure. In some embodiments, method 2000 may be performed by one or more software or hardware components of an encoder (e.g., encoder 200 of FIG. 2), a decoder (e.g., decoder 300 of FIG. 3), or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 2000. In some embodiments, method 2000 may be implemented by a computer program product embodied in a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0082]

[0104] In step 2001, it may be determined whether the target CU is encoded with separate luma and chroma trees. For example, this determination may be made based on whether the condition (treeType ! = SINGLE_TREE) is met. If treeType ! = SINGLE_TREE, it may be determined that the target CU is encoded with separate luma and chroma trees.

[0083]

[0105] Whether the target CU is part of a single-tree slice may be determined in step 2003. In some embodiments, method 2000 may include determining whether the target CU is part of a P slice or a B slice (e.g., slice_type !=1), or determining whether the target CU is part of a single-tree I slice (e.g., qtbtt_dual_tree_intra_flag == 0).

[0084]

[0106] In step 2005, in response to determining that the target CU (a) is coded by separate luma and chroma trees and (b) is part of a single tree slice, it may be determined that palette mode is not allowed for the target CU (e.g., Table 2 of FIG. 8).

[0085]

[0107] 21 shows a flowchart of an exemplary video processing method 2100 according to some embodiments of the present disclosure. In some embodiments, method 2100 may be performed by one or more software or hardware components of an encoder (e.g., encoder 200 of FIG. 2), a decoder (e.g., decoder 300 of FIG. 3), or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 2100. In some embodiments, method 2100 may be implemented by a computer program product embodied in a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0086]

[0108] In step 2101, it may be determined whether the target CU is encoded with separate luma and chroma trees. For example, this determination may be made based on whether the condition (treeType ! = SINGLE_TREE) is met. If treeType ! = SINGLE_TREE, it may be determined that the target CU is encoded with separate luma and chroma trees.

[0087]

[0109] At step 2103, it may be determined whether the target CU is part of a single-tree slice. In some embodiments, method 2100 may include determining whether the target CU is part of a P slice or a B slice (e.g., slice_type !=1), or determining whether the target CU is part of a single-tree I slice (e.g., qtbtt_dual_tree_intra_flag == 0).

[0088]

[0110] In step 2105, in response to determining that the target CU (a) is coded by separate luma and chroma trees and (b) is part of a single tree slice, a reuse flag may be signaled to reuse a palette entry to palette code the target CU. No new palette entry is signaled to palette code the target CU (e.g., Table 3 of FIG. 9).

[0089]

[0111] In some embodiments, method 2100 may include, in response to determining that the target CU (a) is not coded by separate luma and chroma trees or (b) is not part of a single tree slice, signaling a palette entry for palette coding the target CU (e.g., Table 3 of FIG. 9 ).

[0090]

[0112] In some embodiments, method 2100 may include determining whether a pixel in the target CU includes only luma components, and in response to determining that the pixel includes only luma components, signaling only a luma palette escape value for the pixel if the pixel is encoded using an escape mode CU (e.g., Table 3 of FIG. 9).

[0091]

[0113] 22 shows a flowchart of an exemplary video processing method 2200 according to some embodiments of the present disclosure. In some embodiments, method 2200 may be performed by one or more software or hardware components of an encoder (e.g., encoder 200 of FIG. 2), a decoder (e.g., decoder 300 of FIG. 3), or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 2200. In some embodiments, method 2200 may be implemented by a computer program product embodied in a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0092]

[0114] In step 2201, it may be determined whether a pixel in a target coding unit (CU) includes only luma components. In step 2203, in response to determining that the pixel includes only luma components, if the pixel is coded using escape mode, only the luma palette escape value for the pixel may be signaled (e.g., Table 4 of FIG. 11).

[0093]

[0115] 23 shows a flowchart of an exemplary video processing method 2300 according to some embodiments of the present disclosure. In some embodiments, method 2300 may be performed by one or more software or hardware components of a decoder (e.g., decoder 300 of FIG. 3) or an apparatus (e.g., apparatus 400 of FIG. 4). For example, a processor (e.g., processor 402 of FIG. 4) may perform method 2300. In some embodiments, method 2300 may be implemented by a computer program product embodied in a computer-readable medium that includes computer-executable instructions, such as program code, executed by a computer (e.g., apparatus 400 of FIG. 4).

[0094]

[0116] In step 2301, a bitstream may be received. The bitstream may include reuse flags for reusing palette entries to palette-encode a target CU. For example, a decoder (e.g., decoder 300 of FIG. 3) may receive a bitstream that includes one or more reuse flags (e.g., palette_predictor_run in Table 3 of FIG. 9) for reusing palette entries to palette-encode a target CU.

[0095]

[0117] In step 2303, it may be determined whether the target CU is coded with separate luma and chroma trees. For example, this determination may be made based on whether the condition (treeType ! = SINGLE_TREE) is met. If treeType ! = SINGLE_TREE, it may be determined that the target CU is coded with separate luma and chroma trees.

[0096]

[0118] At step 2305, it may be determined whether the target CU is part of a single-tree slice. In some embodiments, method 2300 may include determining whether the target CU is part of a P slice or a B slice (e.g., slice_type !=1), or determining whether the target CU is part of a single-tree I slice (e.g., qtbtt_dual_tree_intra_flag == 0).

[0097]

[0119] At step 2307, in response to determining that the target CU (a) is coded with separate luma and chroma trees and (b) is part of a single-tree slice, the luma and chroma components of the target CU may be decoded based on the received reuse flag. The received bitstream does not include a palette entry for palette coding the target CU. In some embodiments, method 2300 may include, in response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding the luma and chroma components of the target CU based on the received reuse flag and a palette entry for palette coding the target CU in the bitstream.

[0098]

[0120] In some embodiments, method 2300 may include updating a palette predictor of the target CU based on the received reuse flag. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, method 230 may also include updating a palette predictor of the target CU based on the received reuse flag and a palette entry in the bitstream for palette encoding the target CU. In some embodiments, the size of the palette predictor of the target CU is in the range of 0 to 63.

[0099]

[0121] In some embodiments, a non-transitory computer-readable storage medium containing instructions is also provided, which can be executed by a device (such as the disclosed encoders and decoders) to perform the above-described methods. Common forms of non-transitory media include, for example, floppy disks, flexible disks, hard disks, solid-state drives, magnetic tape or other magnetic data storage media, CD-ROMs, other optical data storage media, any physical media with a pattern of holes, RAM, PROMs, and EPROMs, FLASH-EPROMs or other flash memories, NVRAMs, caches, registers, other memory chips or cartridges, and networked versions of the above. A device may include one or more processors (CPUs), input / output interfaces, network interfaces, and / or memory.

[0100]

[0122] The embodiments can be further described using the following clauses. 1. Receiving a first palette entry for palette encoding a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Decode a first component of the target CU based on the first palette entry; Decoding a second component of a target CU based on default palette entries A video processing method comprising: 2. Receiving a first palette entry for palette encoding a target CU; receiving a flag associated with the second palette entry; and Including a second palette entry in the palette predictor of the target CU based on the received flag. 2. The method according to clause 1, comprising: 3. The method of clause 2, wherein the size of the palette predictor for the target CU is in the range of 0 to 63. 4. Receiving a first palette entry for palette encoding the target CU; Updating a palette predictor of the target CU based on the first palette entry 4. The method of any one of clauses 1 to 3, comprising: 5. Determining whether the target CU is part of a single tree slice Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 5. The method of any one of clauses 1 to 4, comprising: 6. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding a first component and a second component of the target CU based on a first palette entry. 6. The method of clause 5, further comprising: 7. The first component is a luma component and the second component is a chroma component, or the first component is a chroma component and the second component is a luma component; 7. The method according to any one of clauses 1 to 6. 8. The method of clause 1, wherein the palette predictor of the target CU is not updated after decoding the first and second components. 9. At least one memory for storing instructions; and at least one processor, wherein the at least one processor: receiving a first palette entry for palette encoding a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Decode a first component of the target CU based on the first palette entry; Decoding a second component of a target CU based on default palette entries a video processing device configured to execute instructions to cause the device to: 10. At least one processor: receiving a flag associated with the second palette entry; and Including a second palette entry in the palette predictor of the target CU based on the received flag. 9. A device as described in clause 9, configured to execute instructions to cause the device to: 11. The apparatus of clause 10, wherein the size of the palette predictor for the target CU is in the range of 0 to 63. 12. At least one processor: Updating a palette predictor of the target CU based on the first palette entry 12. A device according to any one of clauses 9 to 11, configured to execute instructions to cause the device to: 13. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 13. A device according to any one of clauses 9 to 12, configured to execute instructions to cause the device to: 14. At least one processor: In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding a first component and a second component of the target CU based on the first palette entry. 14. A device as described in clause 13, configured to execute instructions to cause the device to: 15. The first component is a luma component and the second component is a chroma component, or the first component is a chroma component and the second component is a luma component; 1. A device according to any one of clauses 9 to 14. 16. The device of clause 9, wherein the palette predictor of the target CU is not updated after decoding the first component and the second component. 17. A non-transitory computer-readable storage medium storing an instruction set, the instruction set comprising: receiving a first palette entry for palette encoding a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Decode a first component of the target CU based on the first palette entry; Decoding a second component of a target CU based on default palette entries A non-transitory computer-readable storage medium executable by one or more processing devices to cause a video processing device to perform the above. 18. The instruction set receiving a flag associated with the second palette entry; and Including a second palette entry in the palette predictor of the target CU based on the received flag. 18. A non-transitory computer-readable storage medium as recited in clause 17, executable by one or more processing devices to cause a video processing device to perform the steps of: 19. The non-transitory computer-readable storage medium of clause 18, wherein the size of the palette predictor for the target CU is in the range of 0 to 63. 20. The instruction set Updating a palette predictor of the target CU based on the first palette entry 20. A non-transitory computer-readable storage medium according to any one of clauses 17 to 19, executable by one or more processing devices to cause a video processing device to perform the steps of: 21. The instruction set Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 21. A non-transitory computer-readable storage medium according to any one of clauses 17 to 20, executable by one or more processing devices to cause a video processing device to perform the steps of: 22. The instruction set In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding a first component and a second component of the target CU based on the first palette entry. 22. A non-transitory computer-readable storage medium as recited in clause 21, executable by one or more processing devices to cause a video processing device to perform the steps of: 23. The first component is a luma component and the second component is a chroma component, or the first component is a chroma component and the second component is a luma component; 23. A non-transitory computer-readable storage medium according to any one of clauses 17 to 22. 24. The non-transitory computer-readable storage medium of clause 17, wherein the palette predictor of the target CU is not updated after decoding the first component and the second component. 25. Signaling a flag indicating that palette mode is enabled for the target coding unit (CU); A video processing method in which a flag is signaled regardless of whether a chroma sampling format is used for a target CU. 26. The method of clause 25, wherein the flag is signaled within a sequence parameter set (SPS). 27.Chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format 27. The method of any one of clauses 25 or 26, comprising one or more of: 28. Determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and determining, in response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, that palette mode is not allowed for the target CU; A video processing method comprising: 29. Determining whether the target CU is part of a single tree slice Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 29. The method of claim 28, comprising: 30. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, determining that palette mode is enabled for the target CU. 29. The method of claim 28, further comprising: 31. Determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, signaling a reuse flag to reuse palette entries for palette coding the target CU; A video processing method in which no new palette entries are signaled to palette encode the target CU. 32. Determining whether the target CU is part of a single tree slice Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 32. The method of claim 31, comprising: 33. In response to the target CU not being part of a single tree slice or not being coded by separate luma and chroma trees, signaling a palette entry for palette coding the target CU. 33. The method of clause 31 or 32, further comprising: 34. Determining whether a pixel in a target CU contains a chroma component, the pixel being encoded using an escape mode; and responsive to the pixel not containing a chroma component, signaling a luma palette escape value for the pixel; 34. The method of any one of clauses 31 to 33, wherein a chroma palette escape value for a pixel is not signaled. 35. Determining whether a pixel in a target coding unit (CU) contains a chroma component, where the pixel is coded using an escape mode; and signaling a luma palette escape value in response to the pixel not containing a chroma component; A video processing method in which pixel-wise chroma palette escape values ​​are not signaled. 36. Receiving a bitstream including a reuse flag for reusing palette entries to palette encode a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, decoding luma and chroma components of the target CU based on the received reuse flag; A video processing method in which the bitstream does not include palette entries for palette encoding target CUs that are part of a single tree slice and are encoded by separate luma and chroma trees. 37. Updating the palette predictor of the target CU based on the received reuse flag. 37. The method of clause 36, further comprising: 38. Determining whether the target CU is part of a single tree slice Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 38. The method of clause 36 or 37, comprising: 39. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding luma and chroma components of the target CU based on the received reuse flag and a palette entry for palette encoding the target CU in the bitstream. 39. The method of clause 38, further comprising: 40. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, updating a palette predictor of the target CU based on the received reuse flag and a palette entry in the bitstream for palette encoding the target CU. 39. The method of claim 38 or 39, further comprising: 41. The method of any one of clauses 37 to 40, wherein the size of the palette predictor for the target CU is in the range of 0 to 63. 42. At least one memory for storing instructions; and at least one processor, the at least one processor comprising: Signaling a flag indicating that palette mode is enabled for the target coding unit (CU). configured to execute instructions to cause the device to The flag is signaled to the video processing equipment whether the chroma sampling format is used for the target CU. 43. The device of clause 42, wherein the flag is signaled within a sequence parameter set (SPS). 44. Chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format 4. A device as described in clause 42 or 43, including one or more of: 45. At least one memory for storing instructions; and at least one processor, the at least one processor comprising: determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and determining, in response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, that palette mode is not allowed for the target CU; a video processing device configured to execute instructions to cause the device to: 46. ​​At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 45. A device as described in clause 45 configured to execute instructions to cause the device to: 47. At least one processor: determining that palette mode is enabled for the target CU in response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice; 46. ​​A device as described in clause 46 configured to execute instructions to cause the device to: 48. At least one memory for storing instructions; and at least one processor, the at least one processor comprising: determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, signaling a reuse flag to reuse palette entries for palette coding the target CU. configured to execute instructions to cause the device to No new palette entries are signaled to palette encode the target CU, video processing device. 49. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 48. A device as described in clause 48 configured to execute instructions to cause the device to: 50. At least one processor: In response to the target CU not being part of a single tree slice or not being coded by separate luma and chroma trees, signaling a palette entry for palette coding the target CU. 49. A device as described in clause 48 or 49 configured to execute instructions to cause the device to 51. Determining whether a pixel in a target CU contains a chroma component, where the pixel is encoded using an escape mode; and signaling a luma palette escape value for the pixel in response to the pixel not including a chroma component, wherein the chroma palette escape value for the pixel is not signaled. 51. A device described in any one of clauses 48 to 50, wherein at least one processor is configured to execute instructions to cause the device to perform the following. 52. At least one memory for storing instructions; and at least one processor, the at least one processor comprising: Determining whether a pixel in a target coding unit (CU) contains a chroma component, the pixel being coded using an escape mode; and Signaling a luma palette escape value in response to a pixel not containing chroma components configured to execute instructions to cause the device to Pixel-wise chroma palette escape values ​​are not signaled to the video processing device. 53. At least one memory for storing instructions; and at least one processor, the at least one processor comprising: receiving a bitstream including a reuse flag for reusing palette entries for palette encoding a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and and decoding the luma and chroma components of the target CU based on the received reuse flag in response to determining that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees. configured to execute instructions to cause the device to A video processing device, wherein the bitstream does not include palette entries for palette encoding target CUs that are part of a single tree slice and are encoded by separate luma and chroma trees. 54. At least one processor: Updating the palette predictor of the target CU based on the received reuse flag. 53. A device as described in clause 53 configured to execute instructions to cause the device to: 55. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 54. A device as described in clause 53 or 54 configured to execute instructions to cause the device to: 56. At least one processor: In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding luma and chroma components of the target CU based on the received reuse flag and a palette entry for palette encoding the target CU in the bitstream. 55. A device as described in clause 55 configured to execute instructions to cause the device to: 57. At least one processor: In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, updating a palette predictor of the target CU based on the received reuse flag and a palette entry in the bitstream for palette encoding the target CU. 57. A device as described in clause 55 or 56, configured to execute instructions to cause the device to 58. The device of clause 54 or 57, wherein the size of the palette predictor for the target CU is in the range of 0 to 63. 59. A non-transitory computer-readable storage medium storing an instruction set, the instruction set comprising: Signaling a flag indicating that palette mode is enabled for the target coding unit (CU). executable by one or more processing devices to cause a video processing device to perform the A non-transitory computer-readable storage medium, wherein the flag is signaled regardless of whether a chroma sampling format is used for the target CU. 60. The non-transitory computer-readable storage medium of clause 59, wherein the flag is signaled within a sequence parameter set (SPS). 61. Chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format 61. A non-transitory computer-readable storage medium according to clause 59 or 60, comprising one or more of: 62. The instruction set determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and determining, in response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, that palette mode is not allowed for the target CU; A non-transitory computer-readable storage medium executable by one or more processing devices to cause a video processing device to perform the above. 63. The instruction set Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 63. A non-transitory computer-readable storage medium as described in clause 62, executable by one or more processing devices to cause a video processing device to perform the steps of: 64. The instruction set In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, determining that palette mode is enabled for the target CU. 64. A non-transitory computer-readable storage medium as described in clause 63, executable by one or more processing devices to cause a video processing device to perform the steps of: 65. A non-transitory computer-readable storage medium storing an instruction set, the instruction set comprising: determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (CU) is coded by separate luma and chroma trees; and In response to determining that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, signaling a reuse flag to reuse palette entries for palette coding the target CU. executable by one or more processing devices to cause the video processing device to perform the A non-transitory computer-readable storage medium, wherein no new palette entries are signaled to palette encode the target CU. 66. The instruction set Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 66. A non-transitory computer-readable storage medium as described in clause 65, executable by one or more processing devices to cause a video processing device to perform the steps of: 67. The instruction set In response to the target CU not being part of a single tree slice or not being coded by separate luma and chroma trees, signaling a palette entry for palette coding the target CU. 67. A non-transitory computer-readable storage medium as described in clause 65 or 66, executable by one or more processing devices to cause a video processing device to perform the steps of: 68. The instruction set determining whether a pixel in the target CU contains a chroma component, the pixel being coded using an escape mode; and signaling a luma palette escape value for the pixel in response to the pixel not including a chroma component, wherein the chroma palette escape value for the pixel is not signaled. 68. A non-transitory computer-readable storage medium according to any one of clauses 65 to 67, executable by one or more processing devices to cause a video processing device to perform the steps of: 69. A non-transitory computer-readable storage medium storing an instruction set, the instruction set comprising: Determining whether a pixel in a target coding unit (CU) contains a chroma component, the pixel being coded using an escape mode; and Signaling a luma palette escape value in response to a pixel not containing chroma components executable by one or more processing devices to cause the video processing device to perform the A non-transitory computer-readable storage medium, in which chroma palette escape values ​​for pixels are not signaled. 70. A non-transitory computer-readable storage medium storing an instruction set, the instruction set comprising: receiving a bitstream including a reuse flag for reusing palette entries for palette coding a target coding unit (CU); determining whether the target CU is part of a single tree slice; Determining whether the target CU is coded with separate luma and chroma trees; and and decoding the luma and chroma components of the target CU based on the received reuse flag in response to determining that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees. executable by one or more processing devices to cause the video processing device to perform the A non-transitory computer-readable storage medium, wherein the bitstream does not include palette entries for palette encoding target CUs that are part of a single tree slice and are encoded by separate luma and chroma trees. 71. The instruction set Updating the palette predictor of the target CU based on the received reuse flag. 71. A non-transitory computer-readable storage medium as described in clause 70, executable by one or more processing devices to cause a video processing device to perform the steps of: 72. The instruction set: Determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice 72. A non-transitory computer-readable storage medium as described in clause 70 or 71, executable by one or more processing devices to cause a video processing device to perform the steps of: 73. The instruction set In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, decoding luma and chroma components of the target CU based on the received reuse flag and a palette entry for palette encoding the target CU in the bitstream. 73. A non-transitory computer-readable storage medium as described in clause 72, executable by one or more processing devices to cause a video processing device to perform the steps of: 74. The instruction set In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, updating a palette predictor of the target CU based on the received reuse flag and a palette entry for palette encoding the target CU in the bitstream. 74. A non-transitory computer-readable storage medium as described in clause 72 or 73, executable by one or more processing devices to cause a video processing device to perform the steps of: 75. The non-transitory computer-readable storage medium of clause 72 or 74, wherein the size of the palette predictor for the target CU is in the range of 0 to 63.

[0101]

[0123] It should be noted that relational terms herein, such as "first" and "second," are used only to distinguish one entity or operation from another, and do not require or imply an actual relationship or ordering between those entities or operations. Also, the words "comprising," "having," "containing," and "including," and other similar forms, are intended to be equivalent in meaning and to be open-ended in that the term or terms following any one of these terms is not an exhaustive list of such term or terms, or limited to only the listed term or terms.

[0102]

[0124] As used herein, unless specifically stated otherwise, the term "or" encompasses all possible combinations unless impracticable. For example, if a database is described as including A or B, the database may include A, or B, or A and B, unless specifically stated otherwise or impracticable. As a second example, if a database is described as including A, B, or C, the database may include A, or B, or C, or A and B, or A and C, or B and C, or A, B, and C, unless specifically stated otherwise or impracticable.

[0103]

[0125] It is understood that the above embodiments can be implemented by hardware, or software (program code), or a combination of hardware and software. If implemented by software, it can be stored in the above computer-readable medium. The software, when executed by a processor, can perform the disclosed methods. The computing units and other functional units described in this disclosure can be implemented by hardware, or software, or a combination of hardware and software. Those skilled in the art will also understand that more than one of the above modules / units can be integrated into one module / unit, and that each of the above modules / units can be further divided into multiple sub-modules / sub-units.

[0104]

[0126] In the foregoing specification, embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. Certain adaptations and modifications of the described embodiments may be made. Other embodiments may become apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. It is intended that the above specification and examples be considered exemplary only, with the true scope and spirit of the invention being indicated by the following claims. Additionally, the order of steps depicted in the figures is intended for illustrative purposes only and is not intended to be limited to any particular order of steps. Thus, one skilled in the art will recognize that these steps may be performed in different orders while performing the same method.

[0105]

[0127] In the drawings and specification, illustrative embodiments have been disclosed. However, many variations and modifications to these embodiments may be made. Accordingly, although specific terms are employed, they are used in a generic and descriptive sense only and not for purposes of limitation.

Claims

1. Determining whether a target coding unit (CU) is part of a single tree slice; determining whether the target CU is coded with separate luma and chroma trees; and In response to determining that the target CU is part of a single-tree slice and is coded by separate luma and chroma trees, encoding a first component of the target CU based on a first palette entry for palette encoding the target CU; encoding a second component of the target CU based on default palette entries; A video processing method comprising:

2. Signaling a flag associated with a second palette entry, the second palette entry being included in a palette predictor of the target CU based on the flag. The method of claim 1 further comprising:

3. The method of claim 2 , wherein the size of the palette predictor for the target CU is in the range of 0 to 63, inclusive.

4. The method of claim 1, further comprising: updating a palette predictor of the target CU based on the first palette entry.

5. determining whether the target CU is part of a single tree slice, determining whether the target CU is part of a P slice or a B slice; or Determining whether the target CU is part of a single-tree I-slice The method of claim 1 , comprising:

6. In response to determining that the target CU is part of a P slice or a B slice, or part of a single-tree I slice, encoding the first component and the second component of the target CU based on the first palette entry. The method of claim 5 further comprising:

7. the first component is a luma component and the second component is a chroma component; or the first component is a chroma component and the second component is a luma component; The method of claim 1.

8. The method of claim 1 , wherein a palette predictor of the target CU is not updated after encoding the first component and the second component.

9. 1. A method for storing a bitstream, said method comprising: generating a bitstream; and storing the bitstream on a non-transitory computer-readable medium, the bitstream comprising: a first palette entry for palette encoding a target coding unit (CU); a default palette entry for palette encoding the target CU; an indicator indicating whether the target CU is part of a single tree slice and whether the target CU is coded by separate luma and chroma trees; Including, In response to the indicator indicating that the target CU is part of a single tree slice and is coded by separate luma and chroma trees, a first component of the target CU is encoded based on the first palette entry; A method wherein a second component of the target CU is encoded based on the default palette entry.

10. The bitstream comprises: a flag associated with the second palette entry; a palette predictor for the target CU including the second palette entry based on the flag; 10. The method of claim 9, further comprising:

11. The bitstream comprises: The method of claim 10 , further comprising a field indicating a size of the palette predictor for the target CU, in the range of 0 to 63, inclusive.

12. The bitstream comprises: a reuse flag indicating whether to reuse a palette entry for palette encoding the target CU; The method of claim 9 , wherein no new palette entries are signaled to palette encode the target CU.

13. 1. A video decoder capable of enabling a palette mode for a non-4:4:4 color format, the non-4:4:4 color format including at least one of a 4:2:0 color format, a 4:2:2 color format, or a monochrome color format, the video decoder comprising: means for receiving a first palette entry for palette encoding a target coding unit (CU); means for determining whether the target CU is part of a single tree slice; means for determining whether the target CU is coded with separate luma and chroma trees; In response to determining that the target CU is part of a single-tree slice and is coded by separate luma and chroma trees, Decoding a first component of the target CU based on the first palette entry; means for decoding a second component of the target CU based on default palette entries; a video decoder including:

Images