Video processing method and apparatus 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 herein.

[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 sequence of still pictures (or "frames") that capture visual information. To reduce storage memory and transmission bandwidth, a 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, transformation, 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 more and more advanced video coding techniques are adopted into video standards, the coding efficiency of the new video coding standards becomes higher and higher. Summary of the Invention [Means for solving the problem]

[0004] Summary of the Disclosure

[0004] Embodiments of the present disclosure provide a method and apparatus for signaling and using a palette mode. In some example embodiments, a 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 by separate luma and chroma trees, and in response to determining that the target CU is part of a single-tree slice and coded 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 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 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 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 by 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 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 description 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. [Diagram 2]

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

[0010] 2 shows a schematic diagram of an example 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 in accordance with some embodiments of the present disclosure. [Diagram 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] 4 illustrates 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 an example 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 an example Table 2 illustrating a portion of a coding unit syntax table according to some embodiments of the present disclosure. [Figure 9A]

[0016] 1 shows an example 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 example 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 example 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] 1 shows an example Table 4 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. [Figure 12A]

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

[0020] 1 shows an example 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 example decoding process for palette mode, according to some embodiments of the present disclosure. [Figure 15]

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

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

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

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

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

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

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

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

[0030] 1 shows a flowchart of another example video processing method according to some embodiments of the present disclosure. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0009] Detailed Description

[0031] Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. The following description refers to the accompanying drawings, in which the same numbers in different drawings represent the same or similar elements unless otherwise stated. The implementations described in the following description of the 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 described in the appended claims. Certain aspects of the present disclosure are described in more detail below. In case of conflict with incorporated terms and / or definitions, the terms and definitions provided herein shall 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 techniques to surpass HEVC using the joint exploration model (JEM) reference software. As the coding techniques have been incorporated into JEM, JEM has achieved significantly higher coding performance than HEVC. VCEG and MPEG have officially begun work on the next generation video compression standard to 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 a time sequence to store visual information. A video capture device (e.g., a camera) can be used to capture and store those pictures in a 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 a display capability) can be used to display such pictures in a time sequence. In some applications, the 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 supervision, conferencing, live broadcast, etc.

[0014]

[0036] To reduce the storage space and transmission bandwidth required in 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 processor of a general-purpose computer) or dedicated hardware. The compression module is commonly called an "encoder" and the decompression module is commonly called a "decoder." The 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 the 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 the encoders and decoders may include any suitable computer-implemented algorithm or process fixed in program code, computer-executable instructions, firmware, or a computer-readable medium. Video compression and decompression may be performed by a variety of algorithms or standards, such as MPEG-1, MPEG-2, MPEG-4, H.26x family, etc. 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 reconstruction of a picture 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, which is a tradeoff to reduce the required storage space and transmission bandwidth.

[0016]

[0038] Useful information of a picture being encoded (called the "current picture") includes changes with respect 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 reference to 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 previous and future pictures as reference pictures (i.e., the references are "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 for receiving video from a video content provider (e.g., a video broadcast transceiver).

[0019]

[0041] As shown in FIG. 1, a video sequence 100 may include a series of pictures arranged in time 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 whose reference picture is picture 102 itself. Picture 104 is a P-picture whose reference picture is picture 102, as indicated by the arrow. Picture 106 is a B-picture whose reference pictures are pictures 104 and 108, as indicated by the arrows. In some embodiments, the reference picture of a picture (e.g., picture 104) may not be immediately preceding or following the picture. For example, the reference picture of 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 embodiment of the reference pictures 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, whose boundaries are indicated by dashed lines. In some embodiments, the elementary processing units may be referred to as "macroblocks" in some video coding standards (e.g., the MPEG family, H.261, H.263, or H.264 / AVC) or as "coding tree units" (CTUs) in some other video coding standards (e.g., H.265 / HEVC or H.266 / VVC). The elementary processing units may have variable sizes of pictures, such as 128x128, 64x64, 32x32, 16x16, 4x8, 16x32, or any shape and size of pixels. The size and shape of the elementary processing units may be selected for each picture based on a balance between coding efficiency and the level of detail to be maintained in the elementary processing units.

[0021]

[0043] A basic processing unit may be a logical unit that may include a collection of different types of video data stored in a 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 (wherein the luma and chroma components may have the same size of basic processing unit). The luma and chroma components may be 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 may be repeated on each of its luma and chroma components.

[0022]

[0044] Video coding has multiple stages of operation, examples of which are shown in FIG. 2 and FIG. 3. At each stage, the size of the basic processing unit may still be too large to process, 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 the basic processing units, the basic processing subunits are also logical units that may include 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 on each of its luma and chroma components. Note that such division can be performed on 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), the 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 split 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 decide the prediction type for each individual basic processing sub-unit.

[0024]

[0046] As another example, in the prediction stage (one example of which is shown in FIG. 2), the encoder can perform prediction operations at the level of the basic processing subunit (e.g., CU). However, in some cases, the basic processing subunit may still be too large to process. The encoder can further divide the basic processing subunit 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 (one example of which is shown in FIG. 2), the encoder can perform transform operations on residual elementary processing subunits (e.g., CUs). However, in some cases, the elementary processing subunits may still be too large to process. The encoder can further divide the elementary 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 level of the segments. Note that the division scheme of the same elementary 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 units 112 are further divided into 3×3 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 not depend on information from any other region of the picture. That is, each region of a picture can be processed independently. In this way, the 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 correctly encode or decode other regions of the same picture without relying on the corrupted or lost data, thus providing error resilience capabilities. 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 of the video sequence 100 may have different partitioning schemes for dividing the picture into regions.

[0028]

[0050] For example, in Figure 1, structure 110 is divided into three regions 114, 116, and 118, whose boundaries 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 sub-units, and regions of structure 110 in Figure 1 are merely examples, and the present disclosure does not limit the embodiments thereof.

[0029]

[0051] 2 illustrates 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-coding or inter-coding of blocks in 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-modes may refer to several spatial-based compression modes. Inter-modes (such as unidirectional 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 16×16 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, an extended block size (e.g., a coding tree unit (CTU)) may be used to compress video signals with a resolution of, for example, 1080p or higher. In HEVC, a CTU may include up to 64×64 luma samples, corresponding chroma samples, and related syntax elements. In VVC, the size of the CTU may be further increased to include 128×128 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 by 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 coded 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] The 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. The temporal prediction for the video block may be signaled by one or more motion vectors. In unidirectional temporal prediction, only one motion vector is used to generate a prediction signal for the current block, pointing to one reference picture. In bidirectional temporal prediction, on the other hand, two motion vectors may be used, each pointing to a respective reference picture, to generate a prediction signal for the current block. The 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 from which the temporal prediction signal may come.

[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 at 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 at 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 may be used to provide inter-prediction reference samples for encoding other video blocks. To form the 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 the 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 the present disclosure. With reference to FIG. 3, a video bitstream 302 may be unpacked or entropy decoded in an entropy decoding unit 308. The 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 an inverse quantization unit 310 and an 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 a 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 may be used 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 an end user to view.

[0037]

[0059] FIG. 4 is a block diagram of an example 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 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., "CPU"), graphic processing units (i.e., "GPU"), neural processing units ("NPU"), microcontroller units ("MCU"), 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 together 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 a memory 404 configured to store data (e.g., an instruction set, computer code, or 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 the data for processing (e.g., via a 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 several random access memories (RAM), read-only memories (ROM), optical disks, magnetic disks, hard drives, solid-state drives, flash drives, security digital (SD) cards, memory sticks, or compact flash (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 communications device that transfers data between components within apparatus 400, such as an internal bus (eg, a CPU memory bus) or an external bus (eg, 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 are 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 communication network, etc.) In some embodiments, the network interface 406 may include any combination of a number of 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, or cellular network chips, etc.

[0042]

[0064] In some embodiments, optionally, apparatus 400 may further include a peripheral interface 408 to provide a connection to one or more peripheral devices. As shown in FIG. 4, the peripheral devices may include, but are not limited to, a cursor control device (e.g., a mouse, a touchpad, or a touch screen), 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 any 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 to code a picture or slice may be signaled at a high level, for example, using the init_qp_minus26 syntax element in the picture parameter set (PPS) and using the slice_qp_delta syntax element in the slice header. Additionally, the QP value may 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 utilized to code a current CU, the sample values ​​at each position in the CU are represented by a small set of representative color values. The set is called a palette (e.g., palette 510). For sample positions (e.g., positions 501, 502, or 503) that have values ​​close to the palette colors, the 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 positions (e.g., position 504) in the CU that use an escape color index (e.g., index 4), the (quantized) color component values ​​are signaled for each of those positions.

[0047]

[0069] To encode the palette, a palette predictor is kept. 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 entry. After encoding a palette-encoded CU, the palette predictor is updated using the current palette, and entries from the past 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 size allowed.

[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 FIG. 5) is assigned to be the escape symbol.

[0049]

[0071] Referring again to FIG. 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, the palette mode is only allowed for 4:4:4 color format. However, a large amount of video content may be encoded in other color formats, such as 4:2:0 chroma subsampling format. This disclosure provides a method for extending the palette mode to other chroma formats, such as monochrome, 4:2:0, 4:2:2, etc.

[0051]

[0073] Furthermore, in slices with dual luma / chroma trees, the palette is applied separately to luma (Y component) and chroma (Cb and Cr components). In single-tree slices, the palette is applied jointly to 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 allowable minimum chroma coding block size, coding units (CUs) of single-tree slices may have separate luma and chroma trees. Thus, a joint palette cannot be applied to a dual-tree CU (even if the CU belongs to a single-tree slice), since the luma and chroma of the dual-tree CU are processed separately. Thus, 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 slice level but dual-tree at CU level) while extending the 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 apparatuses for applying a palette mode to a single tree slice having a color format other than 4:4:4 color format (or a non-4:4:4 color format) and 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 an 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 in strikethrough in box 701 are proposed to be deleted from the current VVC Draft 7, and syntax elements 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), in slices with a single tree, palette mode is applied to Y, Cb, and Cr components jointly. P and B slices are always coded as single-tree slices. The tree structure of an I-slice is signaled by the SPS syntax, e.g., 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 splitting of chroma is not allowed but further splitting of luma is allowed, so the coding unit of a single-tree slice can have separate luma and chroma trees. In single-tree coding, a SCIPU is defined as a coding tree node whose chroma block size is equal to or larger 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 raises a problem with applying a palette mode to a single-tree slice with a dual-tree CU. The present disclosure provides several embodiments to address this problem.

[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 illustrates an example Table 2 showing 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., palette_predictor_run syntax element) is signaled without adding a new palette entry (e.g., 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. Thus, sending a new palette entry for the local dual tree block is restricted. FIG. 9 illustrates an example Table 3 showing a portion of a palette coding syntax table according to some embodiments of the present disclosure. The palette coding syntax table of Table 3 can apply the palette mode 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 FIG. 9, both bold and shaded in box 903).

[0059]

[0081] 10 illustrates an example decoding process for palette mode according to some embodiments of the present disclosure. The decoding process is covered in 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, the entry for the current palette is placed before the new palette predictor. Then, entries from the past palette predictor that are not reused in the current palette are added to the end of the new palette predictor. In the local dual tree block, 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 a luma (or chroma) component, 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 an example Table 4 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. The palette encoding syntax table of Table 4 can apply the palette mode to a CU that contains a local dual tree. 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] FIG. 12 illustrates an example palette encoding semantics and decoding process for palette mode according to some embodiments of the present disclosure. As shown in FIG. 12, the 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 performing a palette predictor update, default values ​​are first filled in the current palette (see bold semantics in FIG. 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 ] is 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, which is 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 sorting 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 an example Table 5 illustrating a portion of a palette encoding syntax table according to some embodiments of the present disclosure. The palette encoding syntax table of Table 5 can apply the palette mode to a CU that contains a local dual tree. 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 illustrates 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 box 1401 and box 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 the local dual tree luma block in the same way as the palette mode applied to the single tree block. The palette mode is disabled in the local dual tree chroma block. Since the local dual tree luma block can only contain luma components, the values ​​of the luma components are signaled and default values ​​can be set for the chroma components for new palette entries. As an example, the default values ​​may be related to the bit depth of the video sequence. As another example, the default values ​​may 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 an example Table 6 illustrating a portion of a coding unit syntax table according to some embodiments of the present disclosure. Figure 16 shows an example Table 7 illustrating a portion of a palette coding syntax table according to some embodiments of the present disclosure. The palette coding syntax table can apply a palette mode to a CU that contains a luma local dual tree. Syntax changes 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, the palette design can be simplified by disabling the palette for the chroma local dual tree.

[0071]

[0093] FIG. 17 illustrates an example palette encoding semantics and decoding process for palette mode, according to some embodiments of the present disclosure. As shown in FIG. 17, the 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, the 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 ] is in the range of 0 to 63.

[0072]

[0094] 18 illustrates a flowchart of an exemplary video processing method 1800 according to some embodiments of the present disclosure. In some embodiments, the method 1800 may be performed by one or more software or hardware components of a decoder (e.g., the decoder 300 of FIG. 3) or a device (e.g., the device 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 1800. In some embodiments, the 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., the device 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 that includes 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 encoded with separate luma and chroma trees. For example, this determination may be made based on whether a condition (treeType ! = SINGLE_TREE) is satisfied. If treeType ! = SINGLE_TREE, it may be determined that the target CU is encoded 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 !=I) 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, the method 1800 may include receiving a reuse flag to reuse a palette entry to palette encode the target CU, and updating a palette predictor of the target CU based on the received palette entry 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, the method 1800 may include updating the palette predictor of the target CU based on the received palette entry. 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 illustrates a flowchart of an exemplary video processing method 1900 according to some embodiments of the present disclosure. In some embodiments, the method 1900 may be performed by one or more software or hardware components of an encoder (e.g., the encoder 200 of FIG. 2), a decoder (e.g., the decoder 300 of FIG. 3), or an apparatus (e.g., the apparatus 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 1900. In some embodiments, the method 1900 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., the 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, the 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, the 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, the method 2000 may be performed by one or more software or hardware components of an encoder (e.g., the encoder 200 of FIG. 2), a decoder (e.g., the decoder 300 of FIG. 3), or an apparatus (e.g., the apparatus 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 2000. In some embodiments, the 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., the apparatus 400 of FIG. 4).

[0082]

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

[0083]

[0105] At step 2003, it may be determined whether the target CU is part of a single-tree slice. In some embodiments, the method 2000 may include determining whether the target CU is part of a P slice or a B slice (e.g., slice_type !=I) 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 encoded 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 example video processing method 2100 according to some embodiments of the present disclosure. In some embodiments, the method 2100 may be performed by one or more software or hardware components of an encoder (e.g., the encoder 200 of FIG. 2), a decoder (e.g., the decoder 300 of FIG. 3), or an apparatus (e.g., the apparatus 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 2100. In some embodiments, the 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., the apparatus 400 of FIG. 4).

[0086]

[0108] In step 2101, it may be determined whether the target CU is encoded by separate luma and chroma trees. For example, this determination may be made based on whether a condition (treeType ! = SINGLE_TREE) is satisfied. If treeType ! = SINGLE_TREE, it may be determined that the target CU is encoded by 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 !=I) 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 is (a) not coded by separate luma and chroma trees or (b) 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 illustrates a flowchart of an exemplary video processing method 2200 according to some embodiments of the present disclosure. In some embodiments, the method 2200 may be performed by one or more software or hardware components of an encoder (e.g., the encoder 200 of FIG. 2), a decoder (e.g., the decoder 300 of FIG. 3), or an apparatus (e.g., the apparatus 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 2200. In some embodiments, the 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., the 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 encoded using an escape mode, only a luma palette escape value for the pixel may be signaled (e.g., Table 4 of FIG. 11).

[0093]

[0115] 23 illustrates a flowchart of an exemplary video processing method 2300 according to some embodiments of the present disclosure. In some embodiments, the method 2300 may be performed by one or more software or hardware components of a decoder (e.g., the decoder 300 of FIG. 3) or an apparatus (e.g., the apparatus 400 of FIG. 4). For example, a processor (e.g., the processor 402 of FIG. 4) may perform the method 2300. In some embodiments, the 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., the apparatus 400 of FIG. 4).

[0094]

[0116] In step 2301, a bitstream may be received. The bitstream may include a reuse flag for reusing palette entries to palette code 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 code a target CU.

[0095]

[0117] In step 2303, 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 a condition (treeType ! = SINGLE_TREE) is satisfied. If treeType ! = SINGLE_TREE, it may be determined that the target CU is encoded 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 !=I) 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 in the bitstream for palette coding the target CU.

[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, a 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 is also provided that includes instructions, which can be executed by a device (such as the disclosed encoder and decoder) 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 tapes 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 the second palette entry in the palette predictor of the target CU based on the received flag. 2. The method according to claim 1, 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. 4. Receiving a first palette entry for palette encoding a 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 a 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 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; 7. The method according to any one of clauses 1 to 6. 8. The method of claim 1, wherein the palette predictor of the target CU is not updated after decoding the first component and the second component. 9. At least one memory for storing instructions; and at least one processor, the at least one processor 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 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 the second palette entry in the palette predictor of the target CU based on the received flag. 9. An apparatus as described in clause 9, configured to execute instructions to cause the apparatus 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. An apparatus as described in any one of clauses 9 to 11, configured to execute instructions to cause the apparatus to 13. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether a target CU is part of a single-tree I-slice 13. An apparatus as described in any one of clauses 9 to 12, configured to execute instructions to cause the apparatus 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 a first palette entry. 14. An apparatus as described in clause 13, configured to execute instructions to cause the apparatus 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; 15. A device according to any one of clauses 9 to 14. 16. The device of clause 9, wherein a 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 the 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 described 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 as described in any one of clauses 17 to 19, executable by one or more processing devices to cause a video processing device to perform the above. 21. The instruction set, Determining whether the target CU is part of a P slice or a B slice; or Determining whether a 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 a first palette entry. 22. A non-transitory computer-readable storage medium as described 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 a 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 claim 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 with 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 with separate luma and chroma trees, that a 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 a target CU is part of a single-tree I-slice 29. The method according to 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. 30. The method of claim 29, further comprising: 31. Determining whether the target CU is part of a single tree slice; Determining whether a target coding unit (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, signaling a reuse flag to reuse palette entries for palette coding the target CU; A video processing method, wherein 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 a target CU is part of a single-tree I-slice 32. The method according to 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 claim 31 or 32, further comprising: 34. Determining whether a pixel in a target CU includes a chroma component, the pixel being encoded using an escape mode; and responsive to the pixel not including 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, the pixel being coded using an escape mode; and in response to the pixel not containing chroma components, signaling a luma palette escape value; A video processing method in which the chroma palette escape value for a pixel is not signaled. 36. Receiving a bitstream including a reuse flag for reusing palette entries to palette code 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, decoding luma and chroma components of the target CU based on the received reuse flag; A video processing method, wherein the bitstream does not contain palette entries for palette encoding a target CU that is part of a single tree slice and is 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 claim 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 a target CU is part of a single-tree I-slice 38. The method according to claim 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 in the bitstream for palette encoding the target CU. 39. The method of claim 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 coding the target CU. 40. 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 device whether the chroma sampling format is used for the target CU. 43. The apparatus 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. Apparatus as described in clause 42 or 43, including one or more of the following: 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 with 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 with separate luma and chroma trees, that a 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 a target CU is part of a single-tree I-slice 46. ​​An apparatus as described in clause 45 configured to execute instructions to cause the apparatus to 47. 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, determining that palette mode is enabled for the target CU. 47. An apparatus as described in clause 46, configured to execute instructions to cause the apparatus 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 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, 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. 49. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether a target CU is part of a single-tree I-slice 49. An apparatus as described in clause 48, configured to execute instructions to cause the apparatus 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 includes a chroma component, the pixel being 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, where the chroma palette escape value for the pixel is not signaled. 51. An apparatus as described in any one of clauses 48 to 50, wherein at least one processor is configured to execute instructions to cause the apparatus to perform the 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) includes 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 to palette code 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, decoding a luma component and a chroma component of the target CU based on the received reuse flag. configured to execute instructions to cause the device to A video processing device, wherein the bitstream does not contain 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 a palette predictor of the target CU based on the received reuse flag. 54. An apparatus as described in clause 53, configured to execute instructions to cause the apparatus to 55. At least one processor: Determining whether the target CU is part of a P slice or a B slice; or Determining whether a target CU is part of a single-tree I-slice 55. An apparatus as described in clause 53 or 54, configured to execute instructions to cause the apparatus 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 in the bitstream for palette encoding the target CU. 55. An apparatus as described in clause 55 configured to execute instructions to cause the apparatus 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 coding the target CU. 57. An apparatus as described in clause 55 or 56, configured to execute instructions to cause the apparatus 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 as described in 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 with 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 with separate luma and chroma trees, that a 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 a target CU is part of a single-tree I-slice 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 above. 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. 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 above. 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 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, signaling a reuse flag to reuse palette entries for palette coding the target 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 no new palette entries are signaled to palette encode the target CU. 66. The instruction set comprises: Determining whether the target CU is part of a P slice or a B slice; or Determining whether a target CU is part of a single-tree I-slice 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 above. 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 comprises: determining whether a pixel in a target CU includes a chroma component, the pixel being encoded using an escape mode; and In response to the pixel not including a chroma component, signaling a luma palette escape value for the pixel, where the chroma palette escape value for the pixel is not signaled. A non-transitory computer-readable storage medium as described in any one of clauses 65 to 67, executable by one or more processing devices to cause a video processing device to perform the above. 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) includes 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 a video processing device to perform the A non-transitory computer-readable storage medium, in which a chroma palette escape value for a pixel is 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 to palette code 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 a video processing device to perform the A non-transitory computer-readable storage medium, wherein the bitstream does not include palette entries for palette encoding a target CU that is part of a single tree slice and is encoded by separate luma and chroma trees. 71. The instruction set, Updating a palette predictor of the target CU based on the received reuse flag. 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 above. 72. The instruction set, Determining whether the target CU is part of a P slice or a B slice; or Determining whether a 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 in the bitstream for palette encoding the target CU. 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 above. 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 coding 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 relative 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 order between those entities or operations. Also, the words "comprising," "having," "containing," and "including," as well as 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 enumeration of such term or terms, or limited to only the enumerated term or terms.

[0102]

[0124] As used herein, unless specifically stated otherwise, the term "or" encompasses all possible combinations unless not feasible. For example, if it is stated that a database may include A or B, the database may include A, or B, or A and B, unless specifically stated otherwise or unless not feasible. As a second example, if it is stated that a database may include 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 and B and C, unless specifically stated otherwise or unless not feasible.

[0103]

[0125] It is understood that the above embodiments may be implemented by hardware, or software (program code), or a combination of hardware and software. If implemented by software, it may be stored in the above computer-readable medium. The software, when executed by a processor, may perform the disclosed method. The computing units and other functional units described in this disclosure may 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 may be integrated into one module / unit, and each of the above modules / units may be further divided into multiple sub-modules / sub-units.

[0104]

[0126] In the foregoing specification, the 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 as merely exemplary, 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 to be merely illustrative, and is not intended to be limited to any particular order of steps. Thus, one skilled in the art will appreciate 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 can be made to these embodiments. Thus, although specific terms are employed, they are used in a generic and descriptive sense only and not for purposes of limitation.

Claims

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 coded by separate luma and chroma trees, Decoding a first component of the target CU based on the first palette entry; Decoding a second component of the target CU based on default palette entries. A video processing method comprising:

2. receiving the first palette entry for palette encoding the target CU; receiving a flag associated with the second palette entry; and including the second palette entry in a palette predictor of the target CU based on the received flag. The method of claim 1 , 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. receiving the first palette entry for palette encoding the target CU; updating a palette predictor of the target CU based on the first palette entry; The method of claim 1 , 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 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, decoding 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 decoding the first component and the second component.

9. at least one memory for storing instructions; at least one processor, the at least one processor 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 coded by separate luma and chroma trees, Decoding a first component of the target CU based on the first palette entry; Decoding a second component of the target CU based on default palette entries. a video processing device configured to execute the instructions to cause the device to

10. The at least one processor: receiving a flag associated with the second palette entry; and including the second palette entry in a palette predictor of the target CU based on the received flag.

10. The device of claim 9, configured to execute the instructions to cause the device to:

11. The 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 10. The device of claim 9, configured to execute the instructions to cause the device to:

12. The 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 the first component and the second component of the target CU based on the first palette entry. The device of claim 11 , configured to execute the instructions to cause the device to:

13. The apparatus of claim 9 , wherein a palette predictor of the target CU is not updated after decoding the first component and the second component.

14. 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 coded by separate luma and chroma trees, Decoding a first component of the target CU based on the first palette entry; Decoding a second component of the 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.

15. The instruction set comprises: receiving a flag associated with the second palette entry; and including the second palette entry in a palette predictor of the target CU based on the received flag.

15. The non-transitory computer-readable storage medium of claim 14, executable by the one or more processing devices to cause the video processing device to:

16. The instruction set comprises: updating a palette predictor of the target CU based on the first palette entry; 15. The non-transitory computer-readable storage medium of claim 14, executable by the one or more processing devices to cause the video processing device to:

17. The instruction set comprises: 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 15. The non-transitory computer-readable storage medium of claim 14, executable by the one or more processing devices to cause the video processing device to:

18. The instruction set comprises: 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 first palette entry.

20. The non-transitory computer-readable storage medium of claim 17, executable by the one or more processing devices to cause the video processing device to:

19. 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; 15. The non-transitory computer-readable storage medium of claim 14.

20. The non-transitory computer-readable storage medium of claim 14 , wherein a palette predictor of the target CU is not updated after decoding the first component and the second component.

Images