Image processing method and equipment for using palette mode

Abstract

This disclosure provides a system and method for signaling and using palette modes in image processing. [Solution] According to a particular embodiment disclosed, an exemplary image processing method includes receiving a first palette entry for palette encoding a target coding unit (CU), determining whether the target CU is part of a single tree slice, determining whether the target CU is encoded by separate luma and chroma trees, and, in response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, decoding a first component of the target CU based on the first palette entry and decoding a second component of the target CU based on a default palette entry.

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 on December 3, 2019, and U.S. Provisional Patent Application No. 62 / 952,426, filed on December 22, 2019, which are hereby incorporated by reference in their entirety.

[0002] Technical Field

[0002] This disclosure generally relates to video processing, and more particularly to methods and apparatus for signaling and using a palette mode.

Background Art

[0003] Background

[0003] Video is a series of still pictures (or "frames") that capture visual information. To reduce memory storage and transmission bandwidth, video can be compressed before storage or transmission and restored before display. The compression process is usually called encoding, and the restoration process is usually called decoding. Most commonly, there are various video encoding formats that use standardized video encoding techniques based on prediction, transformation, quantization, entropy coding, and in - loop filtering. Video coding standards such as the HEVC (High Efficiency Video Coding) / H.265 standard, the VVC (Versatile Video Coding) / H.266 standard, and the AVS standard, which specify a particular video coding format, have been developed by standardization organizations. As more advanced video coding techniques are adopted in video standards, the coding efficiency of new video coding standards becomes higher and higher.

Summary of the Invention

Means for Solving the Problems

[0004] Summary of the Disclosure

[0004] Embodiments of the present disclosure describe methods for signaling and using palette modes and The present invention provides a device for which an image processing method is provided. In some exemplary embodiments, the image processing method includes receiving a first palette entry for palette encoding a target coding unit (CU), determining whether the target CU is part of a single tree slice, determining whether the target CU is encoded by separate luma and chroma trees, and in response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, decoding a first component of the target CU based on the first palette entry and decoding a second component of the target CU based on a default palette entry.

[0005]

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

[0006]

[0006] In some embodiments, an exemplary non-temporary computer-readable storage medium is used for instruction The instruction set is stored. The instruction set can be executed by one or more processing units to cause a video processing device to: receive a first palette entry for palette coding a target coding unit (CU); determine whether the target CU is part of a single tree slice; determine whether the target CU is coded by separate luma and chroma trees; and, in response to the determination that the target CU is part of a single tree slice and coded 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 explanation of the drawing

[0007] Embodiments and various aspects of the present disclosure are shown in the following detailed description and accompanying drawings. The various features shown in the drawings are not depicted in proportion to the actual dimensions. [Brief explanation of the drawing]

[0008] [Figure 1]

[0008] This is a schematic diagram showing the structure of an example video sequence according to some embodiments of the present disclosure. [Figure 2]

[0009] Schematic diagrams of exemplary encoders in a hybrid video coding system according to several embodiments of the present disclosure are shown. [Figure 3]

[0010] Schematic diagrams of exemplary decoders in a hybrid video coding system according to several embodiments of the present disclosure are shown. [Figure 4]

[0011] The following are block diagrams of exemplary devices for encoding or decoding video according to some embodiments of the present disclosure. [Figure 5]

[0012] Schematic diagrams of exemplary image blocks encoded in palette mode according to several embodiments of the present disclosure are shown. [Figure 6]

[0013] A schematic diagram of an exemplary process for updating a palette predictor after encoding an encoding unit according to some embodiments of the present disclosure is shown. [Figure 7]

[0014] An exemplary Table 1 showing a part of a sequence parameter set (SPS) syntax table according to some embodiments of the present disclosure is shown. [Figure 8]

[0015] An exemplary Table 2 showing a part of an encoding unit syntax table according to some embodiments of the present disclosure is shown. [Figure 9A]

[0016] An exemplary Table 3 showing a part of a palette encoding syntax table according to some embodiments of the present disclosure is shown. [Figure 9B]

[0016] An exemplary Table 3 showing a part of a palette encoding syntax table according to some embodiments of the present disclosure is shown. [Figure 10A]

[0017] An exemplary decoding process for the palette mode according to some embodiments of the present disclosure is shown. [Figure 10B]

[0017] An exemplary decoding process for the palette mode according to some embodiments of the present disclosure is shown. [Figure 11]

[0018] An exemplary Table 4 showing a part of a palette encoding syntax table according to some embodiments of the present disclosure is shown. [Figure 12A]

[0019] An exemplary palette encoding semantics and decoding process for the palette mode according to some embodiments of the present disclosure is shown. [Figure 12B]

[0019] An exemplary palette encoding semantics and decoding process for the palette mode according to some embodiments of the present disclosure is shown. [Figure 13]

[0020] An exemplary Table 5 showing a part of a palette encoding syntax table according to some embodiments of the present disclosure is shown. [Figure 14]

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

[0022] Shows an exemplary Table 6 that shows a part of the encoding unit syntax table according to some embodiments of the present disclosure. [Figure 16]

[0023] Shows an exemplary Table 7 that shows a part of the palette encoding syntax table according to some embodiments of the present disclosure. [Figure 17A]

[0024] Shows another exemplary palette encoding semantics and decoding process for palette mode according to some embodiments of the present disclosure. [Figure 17B]

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

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

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

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

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

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

[0030] Shows a flowchart of another exemplary video processing method according to some embodiments of the present disclosure.

Mode for Carrying Out the Invention

[0009] Detailed Description

[0031] The following examples will refer in detail to the exemplary embodiments shown in the attached drawings. Unless otherwise noted, the descriptions refer to the appended drawings, where the same numbering in different drawings represents the same or similar elements. The embodiments described below in the exemplary embodiments section do not represent all embodiments consistent with the present invention. Rather, they are merely examples of apparatus and methods consistent with aspects of the present invention described in the appended claims. Specific aspects of this disclosure are described in more detail below. In the event of any conflict between the terms and / or definitions used herein and those provided herein, the terms and definitions provided herein shall prevail.

[0010]

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

[0011]

[0033] To achieve the same subjective quality as HEVC / H.265 with half the bandwidth, JVET uses JEM (Joint Exploration Model) reference software to surpass HEVC. They have developed the necessary technologies. Because the encoding technology was incorporated into JEM, JEM achieved significantly higher encoding performance than HEVC. VCEG and MPEG have officially begun developing a next-generation video compression standard that surpasses HEVC.

[0012]

[0034] The VVC standard is a recently developed standard that offers better compression performance. It continues to incorporate even more encoding techniques. VVC is the same hybrid video encoding used in modern video compression standards such as HEVC, H.264 / AVC, MPEG2, and H.263. Based on the numbering system.

[0013]

[0035] The video is a collection of static pictures arranged in chronological order to store visual information (or " It is a set of frames. The video capture device (e.g., camera) is used to capture those frames. It can be used to capture and store images in chronological order, and a video playback device (e.g., a television, computer, smartphone, tablet computer, video player, or any end-user terminal with display capabilities) can be used to display such pictures in chronological order. 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 purposes such as directing, holding meetings, or live broadcasting.

[0014]

[0036] In order to reduce the memory space and transmission bandwidth required for such applications, Video can be compressed before storage and transmission and decompressed before display. Compression and decompression can be performed by software executed by a processor (e.g., a general-purpose computer processor) or dedicated hardware. The module for compression is generally called an "encoder," and the module for decompression is generally called a "decoder." Encoders and decoders are sometimes collectively called a "codec." Encoders and decoders can be implemented as any of various appropriate hardware, software, or a combination thereof. For example, a hardware implementation of an encoder and decoder may include a network of one or more microprocessors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), discrete logic, or any combination thereof. A software implementation of an encoder and decoder may include any appropriate computer-implemented algorithm or process fixed in program code, computer-executable instructions, firmware, or computer-readable media. Video compression and decompression can be performed using various algorithms such as MPEG-1, MPEG-2, MPEG-4, H.26x, or This can be done according to a standard. Depending on the application, a codec may be able to reconstruct video from a first encoding standard and recompress the reconstructed video using a second encoding standard; in this case, the codec may be called a "transcoder."

[0015]

[0037] The video encoding process is used for reconstructing the picture. Useful information can be identified and retained, while information that is not important for reconstruction can be ignored. If the ignored, non-essential information cannot be fully reconstructed, such an encoding process is sometimes called "irreversible." Otherwise, it is sometimes called "reversible." Most encoding processes are irreversible, which is a trade-off to reduce the required memory space and transmission bandwidth.

[0016]

[0038] Useful information about the encoded picture (called "current picture") The report includes changes to the reference picture (e.g., the previously encoded and reconstructed picture). Such changes may include changes in pixel position, brightness, or color, with position being the most important. Changes in the position of a group of pixels representing an object may reflect the movement of the object between the reference picture and the current picture.

[0017]

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

[0018]

[0040] Figure 1 shows the structure of a video sequence example 100 according to several embodiments of the present disclosure. The video sequence 100 may be live video or captured and archived video. 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 captured by a video capture device (e.g., a camera) The video can be input from a video archive containing the video (e.g., video files stored on a storage device) or from a video feed interface for receiving video from a video content provider (e.g., a video broadcast transceiver).

[0019]

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

[0020]

[0042] Generally, a video codec encodes or decodes the entire picture. The encoding is not performed all at once due to the computational complexity of such tasks. More precisely, they divide the picture into basic segments, and each segment can be encoded or decoded. Such basic segments are referred to in this disclosure as basic processing units ("BPUs"). For example, structure 110 in Figure 1 is a video An example structure of a picture in sequence 100 (for example, any of pictures 102-108) is shown. In structure 110, the picture is divided into 4x4 basic processing units, and their boundaries are shown by dashed lines. In some embodiments, the basic processing units are based on certain video encoding standards (e.g., MPEG, H.261, H.263, or H.264 / AVC) Sometimes called a "macroblock," or in some other video encoding standards (e.g., H.265 / HEVC or H.266 / VVC), a "coding tree unit" (CTU). A basic processing unit can have a variable picture size, such as 128x128, 64x64, 32x32, 16x16, 4x8, 16x32, or any shape and size of pixels. The size and shape of the basic processing unit can be selected for each picture based on a balance between encoding efficiency and the level of detail that should be maintained in the basic processing unit.

[0021]

[0043] The basic processing unit stores data in computer memory (for example, video frame buffers). It may also be a logical unit that may contain a set of different types of video data stored in ( ). For example, the basic processing unit of a color picture may include a luminance component (Y) representing achromatic lightness information, one or more chroma components (e.g., Cb and Cr) representing color information, and associated syntax elements (here, the luminance component and chroma component may have basic processing units of the same size). The luminance component and chroma component are sometimes called a "coding tree block" (CTB) in some video encoding standards (e.g., H.265 / HEVC or H.266 / VVC). The calculation can be performed repeatedly for each of its luma and chroma components.

[0022]

[0044] Video encoding involves multiple computational stages, examples of which are shown in Figures 2 and 3. At each stage, the size of the basic processing unit may still be too large to process, and therefore it may be further divided into segments referred to in this disclosure as “basic processing subunits.” In some embodiments, the basic processing subunits are “blocks” in some video encoding standards (e.g., MPEG family, H.261, H.263, or H.264 / AVC). It is sometimes called, or some other video encoding standards (e.g., H.265 / HEVC). In H.266 / VVC, it is sometimes called a "coding unit" ("CU"). A basic processing subunit may be the same size as or smaller than a basic processing unit. Like a basic processing unit, a basic processing subunit is a logical unit that may contain a set of different types of video data (e.g., Y, Cb, Cr, and associated syntax elements) stored in computer memory (e.g., in a video frame buffer). Any operation performed on a basic processing subunit can be repeated on its luminous and chroma components, respectively. Note that such divisions may be performed to further levels depending on the processing needs. Note that different stages may divide the basic processing unit using different schemes.

[0023]

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

[0024]

[0046] As another example, in the prediction stage (an example of which is shown in Figure 2), The encoder can perform predictive calculations 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 (for example, called "prediction blocks" or "PB (prediction blocks)" in H.265 / HEVC or H.266 / VVC), and perform predictive calculations at the level of these segments.

[0025]

[0047] As another example, in the conversion stage (an example of which is shown in Figure 2), the encoder The encoder can perform transformation operations on the residual basic processing subunit (e.g., CU). However, in some cases, the basic processing subunit may still be too large to process. The encoder then processes the basic processing subunit (for example, called a "transform block" or "TB (transform block)" in H.265 / HEVC or H.266 / VVC) It can be further divided into smaller segments, and transformation operations can be performed at the segment level. Note that the division scheme for the same basic processing subunit may differ between the prediction and transformation stages. For example, in H.265 / HEVC or H.266 / VVC, the prediction and transformation blocks of the same CU may have different sizes and numbers.

[0026]

[0048] In the structure 110 of Figure 1, the basic processing unit 112 consists of a 3x3 basic processing subunit. The image is further divided into knits, their boundaries indicated by dotted lines. Different basic processing units of the same picture may be divided into basic processing subunits in different schemes.

[0027]

[0049] In some embodiments, parallel processing capability, as well as video encoding and deco To provide error tolerance to encoding, a picture can be divided into multiple regions for processing, so that the encoding or decoding process does not depend on information from any other region of the picture. In other words, each region of the picture can be processed independently. This allows the codec to process multiple different regions of the picture in parallel, thus improving encoding efficiency. Also, if data in one region is corrupted during processing or lost during network transmission, the codec can accurately encode or decode other regions of the same picture without relying on the corrupted or lost data, thus providing error tolerance. In some video encoding standards, a picture can be divided into multiple different regions. It can be divided into regions. For example, H.265 / HEVC and H.266 / VVC offer two region types: "slice" and "tile". Note that multiple different pictures in video sequence 100 may have different division schemes for dividing the pictures into regions.

[0028]

[0050] For example, in Figure 1, structure 110 has three regions 114, 116, and 11 It is divided into eight sections, and their boundaries are shown as solid lines within structure 110. Section 114 contains four basic processing units. Sections 116 and 118 each contain six basic processing units. Note that the basic processing units, basic processing subunits, and sections of structure 110 in Figure 1 are merely examples and this disclosure does not limit its embodiments.

[0029]

[0051] Figure 2 shows a hybrid video coding system according to several embodiments of the present disclosure. A schematic diagram of an exemplary encoder 200 is shown. The video encoder 200 can perform intra-coding or inter-coding of blocks within a video frame, including video blocks or partitions or subpartitions of video blocks. Intra-coding can utilize spatial prediction to reduce or eliminate spatial redundancy in the video within a given video frame. Inter-coding can utilize temporal prediction to reduce or eliminate temporal redundancy in the video within adjacent frames of a video sequence. Intra-mode can refer to several spatial-based compression modes. Inter-mode (such as unidirectional or bidirectional prediction) can refer to several temporal-based compression methods.

[0030]

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

[0031]

[0053] The spatial prediction unit 260 will use the same picture / slice containing the current block. Using related information, spatial prediction (e.g., intra-prediction) is performed for the current block / CU. Spatial prediction can use pixels from already encoded adjacent blocks within the same video picture frame / slice to predict the current video block. Spatial prediction can reduce the spatial redundancy inherent in the video signal.

[0032]

[0054] The time prediction unit 262 differs from the picture / slice containing the current block. Information from the picture / slice is used to perform a time prediction (e.g., interpretation) for the current block. Time predictions for a video block can be signaled by one or more motion vectors. In unidirectional time prediction, only one motion vector pointing to one reference picture is used to generate the prediction signal for the current block. On the other hand, in bidirectional time prediction, two motion vectors, each pointing to an individual reference picture, may be used to generate the prediction signal for the current block. The motion vectors can indicate the amount and direction of movement between the current block and one or more related blocks in the reference frame. If multiple reference pictures are supported, one or more reference vectors... A reference index may be transmitted with respect to a video block. One or more reference indices may be used to identify which reference picture in the reference picture store or decode picture buffer (DPB) 264 the time prediction signal may originate from.

[0033]

[0055] The mode determination and encoder control unit 280 within the encoder is, for example, a radar A prediction mode can be selected based on distortion optimization. A prediction block can be obtained based on the determined prediction mode. The prediction block can be subtracted from the current image block in the adder 216. The prediction residual can be transformed by the transformation unit 204 and quantized by the quantization unit 206. To form the reconstruction residual, the quantization residual coefficients can be dequantized in the inverse quantization unit 210 and inverse transformed in the inverse transformation unit 212. To form the reconstruction image block, the reconstruction residual can be added to the prediction block in the adder 226. The reconstruction image block before loop filtering can be used to provide a reference sample for intra-prediction.

[0034]

[0056] The reconstructed video block is loop filtered in loop filter 266. It can be applied to the image. For example, loop filtering such as deblocking filters, sample-adaptive offsets (SAO), and adaptive loop filters (ALF) can be applied. The reconstructed block after loop filtering can be stored in the reference picture store 264 and can be used to provide inter-predictive reference samples for encoding other image blocks. To form the output image bitstream 220, the encoding mode (e.g., inter or intra), prediction mode information, motion information, and quantization residual coefficients can be sent to the entropy encoding unit 208 to further reduce the bitrate, and then the data can be compressed and packed to form the bitstream 220.

[0035]

[0057] Figure 3 shows a hybrid video coding system according to several embodiments of the present disclosure. A schematic diagram of an exemplary decoder 300 is shown. Referring to Figure 3, the video bitstream 302 may be unpacked or entropy-decoded in the entropy decoding unit 308. Encoding mode information can be used to determine whether to select the spatial prediction unit 360 or the temporal prediction unit 362. The prediction mode information can be sent to the corresponding prediction unit to generate a prediction block. For example, motion-compensated prediction may be applied by the temporal prediction unit 362 to form a temporal prediction block.

[0036]

[0058] To obtain the reconstruction residual, the residual coefficients are obtained from the inverse quantization unit 310 and the inverse transformation unit. The data can be sent to the 312. The predicted block and the reconstructed residual can be summed in 326 to form a reconstructed block before loop filtering. The reconstructed block can then be subjected to loop filtering in the loop filter 366. Loop filtering such as deblocking filters, SAO, and ALF can be applied. The reconstructed block after loop filtering can be stored in the reference picture store 364. The reconstructed data in the reference picture store 364 can be used to obtain the decoded video 320 or to predict future video blocks. The decoded video 320 can be displayed on a display device such as a TV, PC, smartphone, or tablet for the end user to view.

[0037]

[0059] Figure 4 shows the encoding or decoding of video according to some embodiments of the present disclosure. This is a block diagram of an exemplary apparatus 400 for that purpose. As shown in Figure 4, the apparatus 400 may include a processor 402. When the processor 402 executes the instructions described herein, the apparatus 400 can become a dedicated machine for video encoding or decoding. The processor 402 is any type capable of manipulating or processing information. It may also be a network of circuits. For example, the processor 402 may include several central processing units (i.e., "CPUs"), graphics processing units (i.e., "GPUs"), neural processing units ("NPUs"), microcontroller units ("MCUs"), optical processors, programmable logic controllers, microcontrollers, microprocessors, digital signal processors, IP (intellectual property) cores, and programmable logic arrays (PLAs). ), may include any combination of programmable array logic (PAL), general-purpose array logic (GAL), composite programmable logic devices (CPLD), field-programmable gate arrays (FPGA), systems-on-chip (SoC), or application-specific integrated circuits (ASIC). In some embodiments, the processor 402 may also be a set of processors grouped as a single logic component. For example, as shown in Figure 4, the processor 402 may include multiple processors, including processor 402a, processor 402b, and processor 402n.

[0038]

[0060] Device 400 receives data (e.g., instruction sets, computer code, or intermediate data). The memory 404 may also include a memory configured to store data, etc. For example, as shown in Figure 4, the stored data may include program instructions (e.g., program instructions for implementing the stages in Figure 2 or 3) and processing data. The processor 402 can access the program instructions and processing data (e.g., via the bus 410) and execute the program instructions to perform calculations or operations on the processing data. The memory 404 may include high-speed random-access storage devices or non-volatile storage devices. 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, SD (security digital) cards, memory sticks, or CompactFlash® (CF) cards. The memory 404 may also be a group of memories (not shown in Figure 4) grouped as a single logical component.

[0039]

[0061] Bus 410 is an internal bus (for example, the CPU memory bus) or an external bus (for example) Alternatively, it may be a communication device that transfers data between components within the device 400, such as a universal serial bus port or a peripheral component interconnection express port.

[0040]

[0062] To simplify the explanation without creating ambiguity, this disclosure uses the following terms: The 402 and other data processing circuits are collectively referred to as the "data processing circuits." The data processing circuits may be implemented entirely as hardware, or as a combination of software, hardware, or firmware. Furthermore, the data processing circuits may be a single, independent module, or may be fully or partially integrated with any other components of the device 400.

[0041]

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

[0042]

[0064] In some embodiments, the device 400 optionally includes one or more peripheral devices. A peripheral interface 408 may be further included to provide connectivity to the vice. As shown in Figure 4, peripheral devices may include (but are not limited to) cursor control devices (e.g., mouse, touchpad, or touchscreen), keyboards, displays (e.g., cathode ray tube displays, liquid crystal displays, or light-emitting diode displays), or video input devices (e.g., cameras, or input interfaces combined with video archives).

[0043]

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

[0044]

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

[0045]

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

[0046]

[0068] Figure 5 shows an example of encoding in palette mode according to several embodiments of the present disclosure. A schematic diagram of the illustrative image block 500 is shown. As shown in Figure 5, when palette mode is used to encode the current CU, the sample value at each position in the CU is represented by a small set of representative color values. This set is called the 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 embodiments disclosed, color values ​​outside the palette can be specified by signaling an escape index (or escape color index). Then, at all positions in the CU (e.g., position 504) using the escape color index (e.g., index 4), the (quantized) color component value is signaled for each of those positions.

[0047]

[0069] To encode the palette, a palette predictor is preserved. The predictor is non-way For a front, it is initialized to 0 (e.g., empty) at the beginning of each slice, and for a wavefront, at the beginning of each CTU row. Figure 6 shows a schematic diagram of an exemplary process 600 for updating the palette predictor after encoding a coding unit, according to some embodiments of the present disclosure. As shown in Figure 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 zero run-length coding, and then the number of new palette entries and the component values ​​of the new palette entries are signaled. After encoding the palette coding CU, the palette predictor is updated to update the current palette Entries from past palette predictors that are updated using and not reused within the current palette are appended to the end of the new palette predictor until the maximum allowed size is reached.

[0048]

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

[0049]

[0071] Referring again to Figure 5, the palette index of the sample in CU (for example, index) Index 0, index 1, index 2, index 3, and index 4 form the palette index map. The index map is encoded using horizontal or vertical traverse scans. The scan order is explicitly signaled in the bitstream using the palette_transpose_flag syntax element. The palette index map is encoded using index-run mode or index-copy mode.

[0050]

[0072] In some embodiments, the palette mode is set to a 4:4:4 color format. Only permitted in certain cases. However, a large amount of video content may be encoded in other color formats, such as the 4:2:0 chroma subsampling format. This disclosure provides a method for extending palette modes to other chroma formats such as monochrome, 4:2:0, and 4:2:2.

[0051]

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

[0052]

[0074] Some embodiments of this disclosure use a color format other than 4:4:4. The present invention provides a method and apparatus for applying palette mode to a single tree slice having a format (or non-4:4:4 color format) and a local dual-tree structure.

[0053]

[0075] Some embodiments of this disclosure are monochrome, 4:2:0, 4:2:2, 4: Palette mode may be permitted for all chroma formats, such as 4:4. Figure 7 shows exemplary Table 1, which illustrates a portion of the SPS syntax table according to several embodiments of the present disclosure. As shown in Table 1, the syntax elements that are struck through in box 701 are proposed to be removed from the current VVC draft 7, and the syntax elements that are italicized in box 702 are proposed to be added to the current VVC draft 7. The SPS flag sps_palette_enabled_flag is chroma_format_idc Signaling can be performed regardless of the values ​​of the syntax elements.

[0054]

[0076] As explained above, current video encoding standards (e.g., VVC Draft 7) In this case, for slices with a single tree, the palette mode is applied together to the Y, Cb, and Cr components. P and B slices are always encoded as single-tree slices. The tree structure of an I slice is signaled by the SPS syntax, e.g., the qtbtt_dual_tree_intra_flag syntax element. A qtbtt_dual_tree_intra_flag syntax element equal to 1 indicates two separate coding_tree syntax elements for luma and chroma with respect to the I slice. Specifies that a coding structure will be used. A qtbtt_dual_tree_intra_flag syntax element equal to 0 means that a separate coding_tree syntax structure will not be used for I slices. Specify that it is not.

[0055]

[0077] Non-interface smallest chrominotherapeutic prediction unit (SCIPU: smallest chroma In the case of an intraprediction unit (CU), further subdivision of chroma is not permitted, but further subdivision of luma is permitted, so a coding unit in 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 16 chroma samples or more and which has at least one child luma block with fewer than 64 luma samples. Therefore, since the luma and chroma of a dual-tree CU are processed separately (even if the dual-tree CU belongs to a single-tree slice), a joint palette cannot be applied to a dual-tree CU. This raises a problem with applying palette mode to a single-tree slice having a dual-tree CU. The present disclosure provides several embodiments to address this problem.

[0056]

[0078] According to some embodiments, if the CU includes a local dual tree, Palette mode is not permitted for CUs. Therefore, palette mode is not permitted for CUs if both of the following conditions are met: (1) the CU is encoded by a separate tree, and (2) the CU belongs to a slice having a single tree. Figure 8 shows exemplary Table 2, which shows a portion of the encoded unit syntax tables according to several embodiments of the present disclosure. The encoded unit syntax tables in Table 2 may not permit palette mode for CUs. Syntax changes that conform to the present disclosure are shown in italics in box 801, as shown in Table 2. Based on the encoded unit syntax tables in Table 2, palette mode is not permitted 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, in order to improve the encoding efficiency of palette mode, Palette mode is applied to CUs that include local dual trees. In local dual tree blocks, reuse flags (e.g., palette_predictor_run) are used without adding new palette entries (e.g., new_palette_entries[ cIdx ][ i ] syntax elements). Syntax elements are signaled. Since a local dual-tree block can only contain luma (or chroma) components, the chroma (or luma) value of a new palette entry may be empty. Therefore, sending new palette entries with respect to a local dual-tree block is restricted. Figure 9 shows an exemplary Table 3 illustrating a portion of the palette coding syntax table according to several embodiments of the present disclosure. The palette coding syntax table in Table 3 allows the palette mode to be applied to CUs containing local dual trees. As shown in Table 3, syntax changes that conform to embodiments of the present invention are indicated in italics within boxes 901-904.

[0058]

[0080] Furthermore, in non-4:4:4 color formats, pixels contain only the lumens component. Therefore, in some embodiments, when encoded using escape mode, only the luma value is signaled for these pixels (see the syntax in Table 3 of Figure 9, both bold and shadowed, in box 903).

[0059]

[0081] Figure 10 shows an exemplary palette mode according to some embodiments of the present disclosure. The decoding process is shown. The decoding process is included in section 8.4.5.3 of the VVC draft 7. The decoding process may include two processes: one process for reconstructing the pixels and another process for updating the palette predictor.

[0060]

[0082] As shown in Figure 10, the decoding process is performed within the VVC draft 7. This may be similar to section 8.4.5.3. The decoding process may involve several syntax changes, as shown in italics within boxes 1001-1003. When updating the palette predictor using the current palette, entries for the current palette are placed before the new palette predictor. Entries from past palette predictors that are not reused in the current palette are then appended to the end of the new palette predictor. In the local dual tree block, each palette entry contains both lumens and chromens. Therefore, all three components are involved in the palette predictor update process. The bitstream requires that the value of PredictorPaletteSize[startComp] be within the range of 0 to 63. This is a requirement for compliance.

[0061]

[0083] According to several embodiments, a pallet motor applied to a single tree block The palette mode can be applied to a local dual-tree block in the same way as the code. Since a local dual-tree block can only contain luminous (or chroma) components, the value of the luminous (or chroma) component is signaled, and a default value can be set for the chroma (or luminous) component for new palette entries. For example, the default value may be related to the bit depth of the video sequence. For another example, the default value may be zero.

[0062]

[0084] Furthermore, in non-4:4:4 color formats, use escape mode When encoded, only the luma value is signaled for pixels that contain only the luma component. Figure 11 shows an exemplary Table 4 illustrating a portion of the palette encoding syntax table according to several embodiments of the present disclosure. The palette encoding syntax table in Table 4 allows the palette mode to be applied to CUs including a local dual tree. Syntax modifications that conform to embodiments of the present invention are shown in italics in boxes 1101 and 1102, as shown in Table 4.

[0063]

[0085] In some embodiments of this disclosure, syntax for local dual trees Sparse can be aligned with syntax parse for single trees. Furthermore, fewer bits are signaled, which can improve the encoding efficiency of palette mode.

[0064]

[0086] Figure 12 shows an exemplary palette mode according to some embodiments of the present disclosure. The palette coding semantics and decoding process are shown. As shown in Figure 12, the proposed syntax changes to sections 7.4.12.6 and 8.4.5.3 in VVC Draft 7 are shown in italics in boxes 1201-1205. In the local dual tree block, when updating the palette predictor, the default value is first filled into the current palette (see the bold semantics in Figure 12). Then, all three components participate in the palette predictor update process. The value of PredictorPaletteSize[startComp] must be within the range of 0 to 63 for bitstream compatibility. It is a requirement.

[0065]

[0087] According to several embodiments, a pallet motor applied to a single tree block The palette mode can be applied to a local dual-tree block in the same way as the code, 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 simplifies the decoding process.

[0066]

[0088] Furthermore, in non-4:4:4 color formats, use escape mode When encoded, only the luma value is signaled for pixels that contain only the luma component. Figure 13 shows an exemplary Table 5 illustrating a portion of the palette encoding syntax table according to several embodiments of the present disclosure. The palette encoding syntax table in Table 5 allows the palette mode to be applied to CUs including a local dual tree. Syntax changes that conform to embodiments of the present invention are shown in italics in boxes 1301 and 1302, as shown in Table 5.

[0067]

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

[0068]

[0090] According to several embodiments, a pallet motor applied to a single tree block The palette mode can be applied to a local dual-tree chroma block in the same way as the code. The palette mode is disabled in a local dual-tree chroma block. Since a local dual-tree chroma block can only contain chroma components, the value of the chroma component is signaled, and a default value can be set for the chroma component for new palette entries. For example, the default value may be related to the bit depth of the video sequence. For another example, the default value may be zero.

[0069]

[0091] Furthermore, in non-4:4:4 color formats, use escape mode When encoded, only the luma value is signaled for pixels containing only the luma component. Figure 15 shows exemplary Table 6, which illustrates a portion of the encoding unit syntax table according to several embodiments of the present disclosure. Figure 16 shows exemplary Table 7, which illustrates a portion of the palette encoding syntax table according to several embodiments of the present disclosure. The palette encoding syntax table allows the palette mode to be applied to CUs containing luma-local dual trees. Syntax changes in Tables 6 and 7 that conform to embodiments of the present invention are shown in italics in boxes 1501 and 1601-1602, respectively.

[0070]

[0092] In some embodiments of this disclosure, with respect to the chroma-local dual tree, Disabling the 't' function can simplify the pallet design.

[0071]

[0093] Figure 17 shows an exemplary palette mode according to some embodiments of the present disclosure. This shows the palette coding semantics and decoding process. As shown in Figure 17, the proposed syntax changes to sections 7.4.12.6 and 8.4.5.3 in VVC Draft 7 are shown in italics in boxes 1701-1705. In the local dual tree block, when updating the palette predictor, the default value is first filled into the current palette. Then, all three components are the palette predictor Involved in the update process. The value of PredictorPaletteSize[startComp] is between 0 and 63. The requirement for bitstream conformance is that it falls within a certain range.

[0072]

[0094] Figure 18 shows an exemplary image processing method 1800 according to several embodiments of the present disclosure. A flowchart is shown. In some embodiments, Method 1800 may be performed by one or more software or hardware components of a decoder (e.g., Decoder 300 in Figure 3) or a device (e.g., Device 400 in Figure 4). For example, a processor (e.g., Processor 402 in Figure 4) can perform Method 1800. In some embodiments, Method 1800 may be implemented by a computer program product embodied in a computer-readable medium containing computer-executable instructions, such as program code executed by a computer (e.g., Device 400 in Figure 4).

[0073]

[0095] Step 1801: Palette entry for palette encoding target CU A decoder (e.g., decoder 300 in Figure 3) can receive a bitstream containing one or more palette entries (e.g., new_palette_entries[ cIdx ][ i ] in Table 3 in Figure 9) for palette encoding the target CU.

[0074]

[0096] In step 1803, the target CU is encoded by separate luma and chroma trees. It is possible to determine whether or not this is the case. For example, this determination can be made based on whether the condition (treeType ! = SINGLE_TREE) is met. If treeType ! = SINGLE_TREE, it can be determined that the target CU is encoded by separate luma and chroma trees.

[0075]

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

[0076]

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

[0077]

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

[0078]

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

[0079]

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

[0080]

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

[0081]

[0103] Figure 20 shows a flowchart of an exemplary image processing method 2000 according to several 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., encoder 200 in Figure 2), a decoder (e.g., decoder 300 in Figure 3), or a device (e.g., device 400 in Figure 4). For example, a processor (e.g., processor 402 in Figure 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 containing computer-executable instructions, such as program code executed by a computer (e.g., device 400 in Figure 4).

[0082]

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

[0083]

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

[0084]

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

[0085]

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

[0086]

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

[0087]

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

[0088]

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

[0089]

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

[0090]

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

[0091]

[0113] Figure 22 shows a flowchart of an exemplary image processing method 2200 according to several 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., encoder 200 in Figure 2), a decoder (e.g., decoder 300 in Figure 3), or a device (e.g., device 400 in Figure 4). For example, a processor (e.g., processor 402 in Figure 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 containing computer-executable instructions, such as program code executed by a computer (e.g., device 400 in Figure 4).

[0092]

[0114] In step 2201, it can be determined whether a pixel in the target coding unit (CU) contains only the luma component. In step 2203, if the pixel contains only the luma component In response to determining that a pixel contains a 'ke', if the pixel is encoded using an escape mode, only the LumaPalette escape value for the pixel can be signaled (e.g., Table 4 in Figure 11).

[0093]

[0115] Figure 23 shows a flowchart of an exemplary image processing method 2300 according to several 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., decoder 300 in Figure 3) or a device (e.g., device 400 in Figure 4). For example, a processor (e.g., processor 402 in Figure 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 containing computer-executable instructions, such as program code executed by a computer (e.g., device 400 in Figure 4).

[0094]

[0116] In step 2301, the bitstream can be received. The bitstream may contain reuse flags for reusing palette entries to palette encode the target CU. For example, the decoder (e.g., decoder 300 in Figure 3) receives a bitstream containing one or more reuse flags (e.g., palette_predictor_run in Table 3 of Figure 9) for reusing palette entries to palette encode the target CU. It is possible.

[0095]

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

[0096]

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

[0097]

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

[0098]

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

[0099]

[0121] In some embodiments, non-temporary computer-readable storage media containing instructions are also provided, which can be executed by a device (such as an encoder and decoder as disclosed) to perform the methods described above. Common forms of non-temporary 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 having a pattern of holes, RAM, PROMs, and EPROMs, FLASH®-EPROMs or other flash memory, NVRAMs, caches, registers, other memory chips or cartridges, and networked versions thereof. A device may include one or more processors (CPUs), input / output interfaces, network interfaces, and / or memory.

[0100]

[0122] Embodiments can be further described using the following clauses. 1. Receiving a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first palette entry, decode the first component of the target CU. Decode the second component of the target CU based on the default palette entry. A video processing method, including the following. 2. Receiving a first palette entry for palette encoding the target CU, To receive a flag related to the second palette entry, and Based on the received flag, include the second palette entry in the target CU's palette predictor. The method described in Clause 1, including the method described in Clause 1. 3. The method according to Clause 2, wherein the size of the target CU's pallet predictor is within the range of 0 to 63. 4. Receiving a first palette entry for palette encoding the target CU, Updating the target CU's palette predictor based on the first palette entry. The method described in any one of the clauses 1 through 3, including the method described in any one of the clauses 1 through 3. 5. Determining whether the target CU is part of a single tree slice is To determine 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 described in any one of the clauses 1 through 4, including the method described in any one of the clauses 1 through 4. 6. In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, decode the first and second components of the target CU based on the first palette entry. The method described in Clause 5, further including the method described in Clause 5. 7. The first component is a luma component, and the second component is a chroma component, or The first component is the chroma component, and the second component is the luma component. The method described in any one of the provisions 1 through 6. 8. The method according to Clause 1, wherein the palette predictor of the target CU is not updated after decoding the first and second components. 9. At least one memory for storing instructions, It includes at least one processor, and at least one processor is To receive a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first palette entry, decode the first component of the target CU. Decode the second component of the target CU based on the default palette entry. A video processing device configured to execute commands to cause a device to perform a certain action. 10. At least one processor, To receive a flag related to the second palette entry, and Based on the received flag, include the second palette entry in the target CU's palette predictor. The equipment described in Clause 9, configured to execute instructions in order to cause the equipment to perform the following. 11. The equipment described in Clause 10, wherein the size of the target CU's pallet predictor is within the range of 0 to 63. 12. At least one processor, Updating the target CU's palette predictor based on the first palette entry. A device as described in any one of clauses 9 through 11, configured to execute instructions in order to cause the device to perform the action. 13. At least one processor, To determine 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. A device as described in any one of clauses 9 through 12, configured to execute instructions in order to cause the device to perform the action. 14. At least one processor, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, the first and second components of the target CU are decoded based on the first palette entry. The equipment described in Clause 13, configured to execute commands in order to cause the equipment to perform the following. 15. The first component is a luma component, and the second component is a chroma component, or The first component is the chroma component, and the second component is the luma component. The equipment specified in any one of clauses 9 through 14. 16. The apparatus described in Clause 9, in which the pallet predictor of the target CU is not updated after decoding the first and second components. 17. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set is: To receive a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first palette entry, decode the first component of the target CU. Decode the second component of the target CU based on the default palette entry. A non-temporary computer-readable storage medium that can be executed by one or more processing units to cause video processing equipment to perform the following actions. 18. The instruction set is, To receive a flag related to the second palette entry, and Based on the received flag, include the second palette entry in the target CU's palette predictor. A non-temporary computer-readable storage medium as described in Clause 17, which can be executed by one or more processing units to cause a video processing device to perform the same action. 19. A non-temporary computer-readable storage medium as described in Clause 18, wherein the size of the target CU's palette predictor is in the range of 0 to 63. 20. The instruction set is, Updating the target CU's palette predictor based on the first palette entry. A non-temporary computer-readable storage medium as described in any one of the clauses 17 to 19, which can be executed by one or more processing units to cause a video processing device to perform the same action. 21. The instruction set is, To determine 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. A non-temporary computer-readable storage medium as described in any one of the clauses 17 to 20, which can be executed by one or more processing units to cause a video processing device to perform the same action. 22. The instruction set is, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, the first and second components of the target CU are decoded based on the first palette entry. A non-temporary computer-readable storage medium as described in Clause 21, which can be executed by one or more processing units to cause a video processing device to perform the same action. 23. The first component is a luma component, and the second component is a chroma component, or The first component is the chroma component, and the second component is the luma component. A non-temporary computer-readable storage medium as described in any one of the clauses 17 through 22. 24. A non-temporary computer-readable storage medium as described in Clause 17, wherein the palette predictor of the target CU is not updated after decoding of the first and second components. 25. Including signaling a flag indicating that palette mode is enabled for a target coding unit (CU), The flag is a video processing method that signals regardless of whether a chromasampling format is used for the target CU. 26. The method according to clause 25, wherein a flag is signaled within the sequence parameter set (SPS). 27. The chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format A method of any one of the provisions of paragraph 25 or 26, including one or more of the above. 28. Determining whether the target CU is part of a single tree slice. To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, it is determined that palette mode is not permitted for the target CU. A video processing method, including the following. 29. Determining whether the target CU is part of a single tree slice is To determine 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 described in Article 28, including the method described in Article 28. 30. In response to the determination that the target CU is part of a P slice or B slice, or part of a single tree I slice, it is determined that pallet mode is permitted for the target CU. The method described in Clause 29, further including the method described in Clause 29. 31. Determine whether the target CU is part of a single tree slice. To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, the system includes signaling a reuse flag to reuse a palette entry to palette encode the target CU. A video processing method in which no new palette entries are signaled to palette encode the target CU. 32. Determining whether the target CU is part of a single tree slice is To determine 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 described in Article 31, including the method described in Article 31. 33. In response to the target CU not being part of a single tree slice or not being encoded by separate luma and chroma trees, signal a palette entry for palette encoding the target CU. The method described in Clause 31 or 32, further including the method described in Clause 31 or 32. 34. Determining whether a pixel in the target CU contains a chroma component, wherein the pixel is encoded using an escape mode, and Further including signaling a luma palette escape value for a pixel in response to the pixel not containing a chroma component, The method described in any one of clauses 31 to 33, wherein chroma palette escape values ​​for pixels are not signaled. 35. Determining whether a pixel in a target coding unit (CU) contains a chroma component, and determining whether the pixel is coded using an escape mode, and This includes signaling a luma palette escape value in response to a pixel not containing a chroma component, A video processing method in which chroma palette escape values ​​for pixels are not signaled. 36. Receiving a bitstream containing a reuse flag for reusing palette entries to palette encode a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To 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 encoded by separate luma and chroma trees, the process includes decoding the luma and chroma components of the target CU based on the received reuse flag. A video processing method in which the bitstream is part of a single tree slice and does not contain palette entries for palette encoding target CUs that are encoded by separate luma and chroma trees. 37. Update the target CU's palette predictor based on the received reuse flag. The method described in Clause 36, further including the method described in Clause 36. 38. Determining whether the target CU is part of a single tree slice is To determine 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 described in Article 36 or 37, including the method described in Article 36 or 37. 39. In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, decode the luma and chroma components of the target CU based on the received reuse flag and the palette entry for palette encoding the target CU within the bitstream. The method described in Article 38, further including the method described in Article 38. 40. In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, update the target CU's palette predictor based on the received reuse flag and the palette entry for palette encoding the target CU in the bitstream. The method described in Clause 38 or 39, further including the method described in Clause 38 or 39. 41. The method according to any one of the clauses 37 to 40, wherein the size of the pallet predictor of the target CU is in the range of 0 to 63. 42. At least one memory for storing instructions, It includes at least one processor, and at least one processor is Signaling a flag indicating that palette mode is enabled for the target coding unit (CU). It is configured to execute commands to cause the device to do so. The flag is signaled to the video processing equipment regardless of whether a chromasampling format is used for the target CU. 43. The equipment described in Clause 42, in which a flag is signaled within the Sequence Parameter Set (SPS). 44. The chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format The equipment described in Clause 42 or 43, including one or more of the following. 45. At least one memory for storing instructions, It includes at least one processor, and at least one processor is To determine whether the target CU is part of a single tree slice, To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, it is determined that palette mode is not permitted for the target CU. A video processing device configured to execute commands to cause a device to perform a certain action. 46. ​​At least one processor, To determine 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 equipment described in Clause 45, configured to execute instructions in order to cause the equipment to perform the following. 47. At least one processor, In response to the determination that the target CU is part of a P slice or B slice, or part of a single-tree I slice, it is determined that pallet mode is permitted for the target CU. The equipment described in Clause 46, configured to execute instructions in order to cause the equipment to perform the following. 48. At least one memory for storing instructions, It includes at least one processor, and at least one processor is To determine whether the target CU is part of a single tree slice, To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single-tree slice and encoded by separate luma and chroma trees, signal a reuse flag to reuse palette entries for palette encoding the target CU. It is configured to execute commands to cause the device to perform the following actions: New palette entries are not signaled in order to palette encode the target CU. Video processing equipment. 49. At least one processor, To determine 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 equipment described in Clause 48, configured to execute instructions in order to cause the equipment to perform the following. 50. At least one processor, In response to the target CU not being part of a single tree slice or not being encoded by separate luma and chroma trees, signaling a palette entry for palette encoding the target CU. A device as described in Clause 48 or 49, configured to execute instructions in order to cause the device to perform a certain action. 51. Determining whether a pixel in a target CU contains a chroma component, and that the pixel is encoded using an escape mode, and Signaling the chroma palette escape value for a pixel in response to the pixel not containing a chroma component, wherein the chroma palette escape value for a pixel is not signaled, or is signaled. A device as described in any one of the clauses 48 to 50, wherein at least one processor is configured to execute instructions to cause the device to perform the action. 52. At least one memory for storing instructions, It includes at least one processor, and at least one processor is Determining whether a pixel in a target coding unit (CU) contains a chroma component, wherein the pixel is coded using an escape mode, and Signaling a luma palette escape value in response to a pixel not containing a chroma component. It is configured to execute commands to cause the device to perform the following actions: Chroma palette escape values ​​related to pixels are not signaled in video processing equipment. 53. At least one memory for storing instructions, It includes at least one processor, and at least one processor is Receiving a bitstream containing reuse flags for reusing palette entries to palette encode target coding units (CUs), To determine whether the target CU is part of a single tree slice, To 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 encoded by separate luma and chroma trees, decode the luma and chroma components of the target CU based on the received reuse flag. It is configured to execute commands to cause the device to perform the following actions: A video processing device in which the bitstream is part of a single-tree slice and does not contain palette entries for palette encoding target CUs that are encoded by separate luma and chroma trees. 54. At least one processor, Update the target CU's palette predictor based on the received reuse flag. The equipment described in Clause 53, configured to execute instructions in order to cause the equipment to perform the following. 55. At least one processor, To determine 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 equipment described in Clause 53 or 54, configured to execute instructions in order to cause the equipment to perform the action. 56. At least one processor, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, the luma and chroma components of the target CU are decoded based on the received reuse flag and the palette entry for palette encoding the target CU within the bitstream. The equipment described in Clause 55, configured to execute instructions in order to cause the equipment to perform the following. 57. At least one processor, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, update the target CU's palette predictor based on the received reuse flag and the palette entry for palette encoding the target CU within the bitstream. The equipment described in Clause 55 or 56, configured to execute instructions in order to cause the equipment to perform the action. 58. The apparatus described in Clause 54 or 57, wherein the size of the target CU's pallet predictor is in the range of 0 to 63. 59. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set is: Signaling a flag indicating that palette mode is enabled for the target coding unit (CU). This can be performed by one or more processing units in order to have the video processing equipment perform the task. The flag is a non-temporary, computer-readable storage medium that signals regardless of whether a chromosampling format is used for the target CU. 60. A non-temporary computer-readable storage medium as described in Clause 59, in which a flag is signaled within a Sequence Parameter Set (SPS). 61. The chroma sampling format is 4:4:4 format, 4:2:2 format, or 4:2:0 format A non-temporary computer-readable storage medium as defined in Clause 59 or 60, including one or more of the following: 62. The instruction set is, To determine whether the target CU is part of a single tree slice, To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single tree slice and encoded by separate luma and chroma trees, it is determined that palette mode is not permitted for the target CU. A non-temporary computer-readable storage medium that can be executed by one or more processing units to cause video processing equipment to perform the following actions. 63. The instruction set is, To determine 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. A non-temporary computer-readable storage medium as described in Clause 62, which can be executed by one or more processing units to cause a video processing device to perform the same action. 64. The instruction set is, In response to the determination that the target CU is part of a P slice or B slice, or part of a single-tree I slice, it is determined that pallet mode is permitted for the target CU. A non-temporary computer-readable storage medium as described in Clause 63, which can be operated by one or more processing units to cause a video processing device to perform the same action. 65. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set The t is, To determine whether the target CU is part of a single tree slice, To determine whether the target coding unit (CU) is coded by separate luma and chroma trees, and In response to determining that the target CU is part of a single-tree slice and encoded by separate luma and chroma trees, signal a reuse flag to reuse palette entries for palette encoding the target CU. This can be performed by one or more processing units in order to have the video processing equipment perform the task. A non-temporary, computer-readable storage medium in which no new palette entries are signaled to encode the target CU. 66. The instruction set is, To determine 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. A non-temporary computer-readable storage medium as described in Clause 65, which can be operated by one or more processing units to cause a video processing device to perform the same action. 67. The instruction set is, In response to the target CU not being part of a single tree slice or not being encoded by separate luma and chroma trees, signaling a palette entry for palette encoding the target CU. A non-temporary computer-readable storage medium as described in Clause 65 or 66, which can be operated by one or more processing units to cause a video processing device to perform the same action. 68. The instruction set is, The determination of whether a pixel in the target CU contains a chroma component, and that the pixel is encoded using an escape mode, and Signaling a chroma palette escape value for a pixel in response to the pixel not containing a chroma component, while not signaling a chroma palette escape value for a pixel. A non-temporary computer-readable storage medium as described in any one of the clauses 65 to 67, which can be operated by one or more processing units to cause a video processing device to perform the same action. 69. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set is: Determining whether a pixel in a target coding unit (CU) contains a chroma component, wherein the pixel is coded using an escape mode, and Signaling a luma palette escape value in response to a pixel not containing a chroma component. This can be performed by one or more processing units in order to have the video processing equipment perform the task. Chroma palette escape values ​​for pixels are not signaled and are stored in non-temporary, computer-readable storage media. 70. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set is: Receiving a bitstream containing reuse flags for reusing palette entries to palette encode target coding units (CUs), To determine whether the target CU is part of a single tree slice, To 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 encoded by separate luma and chroma trees, decode the luma and chroma components of the target CU based on the received reuse flag. This can be performed by one or more processing units in order to have the video processing equipment perform the task. The bitstream is part of a single tree slice and separate Luma and Kuromatsuri A non-temporary, computer-readable storage medium that does not contain palette entries for palette encoding target CUs encoded by -. 71. The instruction set is, Update the target CU's palette predictor based on the received reuse flag. A non-temporary computer-readable storage medium as described in Clause 70, which can be executed by one or more processing units to cause a video processing device to perform the same action. 72. The instruction set is, To determine 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. A non-temporary computer-readable storage medium as described in Clause 70 or 71, which can be operated by one or more processing units to cause a video processing device to perform the same action. 73. The instruction set is, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, the luma and chroma components of the target CU are decoded based on the received reuse flag and the palette entry for palette encoding the target CU within the bitstream. A non-temporary computer-readable storage medium as described in Clause 72, which can be executed by one or more processing units to cause a video processing device to perform the same action. 74. The instruction set is, In response to determining that the target CU is part of a P slice or B slice, or part of a single-tree I slice, update the target CU's palette predictor in the bitstream based on the received reuse flag and the palette entry for palette encoding the target CU. A non-temporary computer-readable storage medium as described in Clause 72 or 73, which can be operated by one or more processing units to cause a video processing device to perform the same action. 75. A non-temporary computer-readable storage medium as described in Clause 72 or 74, wherein the size of the target CU's pallet predictor is in the range of 0 to 63.

[0101]

[0123] It should be noted that the relational terms used herein, such as "first" and "second," are used solely to distinguish one entity or action from another, and do not require or imply any actual relationship or order between these entities or actions. Also, the words "comprising," "having," "containing," and "including," as well as other similar forms, are used. It is intended that these terms be of equivalent meaning, and that the one or more terms following any one of these terms are not exhaustive lists of such terms, or are not limited to only the listed terms.

[0102]

[0124] In this specification, unless otherwise specified, the term “or” encompasses all possible combinations, unless impractical. For example, if it is stated that a database may contain A or B, then unless otherwise specifically stated or impractical, the database may contain A or B, or A and B. As a second example, if it is stated that a database may contain A, B, or C, then unless otherwise specified or impractical, the database may contain A or B, or C, or A and B, or A and C, or B and C, or A and B and C.

[0103]

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

[0104]

[0126] The above specification describes embodiments with respect to numerous specific details that may vary depending on the embodiment. Specific adaptations and modifications of the described embodiments may be made. Other embodiments may become apparent to those skilled in the art by considering the specification and practice of the invention disclosed herein. The above specification and examples are intended to be merely illustrative, and the true scope and spirit of the invention are shown by the following claims. Furthermore, the order of steps shown in the drawings is intended to be for illustrative purposes only and is not intended to limit the steps to any particular order. Therefore, those skilled in the art will understand that these steps may be performed in different orders while carrying out the same method.

[0105]

[0127] The drawings and specification disclose exemplary embodiments. However, many variations and modifications can be made to these embodiments. Therefore, while specific terms are used, they are used merely in a general and descriptive sense and are not intended to be limiting.

Claims

1. To receive a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first pallet entry, the first component of the target CU is decoded. Decode the second component of the target CU based on the default palette entry. A video processing method, including the following.

2. Receiving the first palette entry for palette encoding the target CU, To receive a flag related to the second palette entry, and Based on the received flag, include the second pallet entry in the pallet predictor of the target CU. The method according to claim 1, including the method described in claim 1.

3. The method according to claim 2, wherein the size of the pallet predictor of the target CU is within the range of 0 to 63 (including both ends).

4. Receiving the first palette entry for palette encoding the target CU, Updating the pallet predictor of the target CU based on the first pallet entry. The method according to claim 1, including the method described in claim 1.

5. Determining whether the target CU is part of a single tree slice is To determine whether the target CU is part of a P slice or a B slice, or To determine whether the target CU is part of a single-tree I-slice. The method according to claim 1, including the method described in claim 1.

6. In response to the determination that the target CU is part of a P slice or a B slice, or part of a single tree I slice, the first and second components of the target CU are decoded based on the first palette entry. The method according to 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 the chroma component, and the second component is the luma component. The method according to claim 1.

8. The method according to claim 1, wherein the pallet 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, It includes at least one processor, and the at least one processor is To receive a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first pallet entry, the first component of the target CU is decoded. Decode the second component of the target CU based on the default palette entry. A video processing device configured to execute the aforementioned commands in order to cause the device to perform the following action.

10. The aforementioned at least one processor, To receive a flag related to the second palette entry, and Based on the received flag, include the second pallet entry in the pallet predictor of the target CU. The apparatus according to claim 9, configured to execute the command in order to cause the apparatus to perform the above.

11. The aforementioned at least one processor, To determine whether the target CU is part of a P slice or a B slice, or To determine whether the target CU is part of a single-tree I-slice. The apparatus according to claim 9, configured to execute the command in order to cause the apparatus to perform the above.

12. The aforementioned at least one processor, In response to the determination that the target CU is part of a P slice or a B slice, or part of a single tree I slice, the first and second components of the target CU are decoded based on the first palette entry. The apparatus according to claim 11, configured to execute the command in order to cause the apparatus to perform the above.

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

14. A non-temporary computer-readable storage medium for storing an instruction set, wherein the instruction set is: To receive a first palette entry for palette coding a target coding unit (CU), To determine whether the target CU is part of a single tree slice, To determine whether the target CU is encoded by separate luma and chroma trees, and In response to the determination that the target CU is part of a single tree slice and is encoded by separate luma and chroma trees, Based on the first pallet entry, the first component of the target CU is decoded. Decode the second component of the target CU based on the default palette entry. A non-temporary computer-readable storage medium that can be executed by one or more processing units to cause video processing equipment to perform the following actions.

15. The aforementioned instruction set, To receive a flag related to the second palette entry, and Based on the received flag, include the second pallet entry in the pallet predictor of the target CU. A non-temporary computer-readable storage medium according to claim 14, which can be executed by one or more processing units to cause the video processing equipment to perform the aforementioned processing.

16. The aforementioned instruction set, Updating the pallet predictor of the target CU based on the first pallet entry. A non-temporary computer-readable storage medium according to claim 14, which can be executed by one or more processing units to cause the video processing equipment to perform the aforementioned processing.

17. The aforementioned instruction set, To determine whether the target CU is part of a P slice or a B slice, or To determine whether the target CU is part of a single-tree I-slice. A non-temporary computer-readable storage medium according to claim 14, which can be executed by one or more processing units to cause the video processing equipment to perform the aforementioned processing.

18. The aforementioned instruction set, In response to the determination that the target CU is part of a P slice or a B slice, or part of a single tree I slice, the first and second components of the target CU are decoded based on the first palette entry. A non-temporary computer-readable storage medium according to claim 17, which can be executed by one or more processing units to cause the video processing equipment to perform the aforementioned processing.

19. The first component is a luma component, and the second component is a chroma component, or The first component is the chroma component, and the second component is the luma component. The non-temporary computer-readable storage medium according to claim 14.

20. The non-temporary computer-readable storage medium according to claim 14, wherein the pallet predictor of the target CU is not updated after decoding the first component and the second component.

Images