Signaling of quantization parameters in video processing

Abstract

This provides a method for processing video content. [Solution] One exemplary method includes receiving a bitstream containing coded video data, determining a first parameter of the coded block, determining one or more second parameters related to a delta quantization parameter (QP) value or a chroma QP offset value according to the first parameter, and determining at least one of the delta QP value or chroma QP offset value according to one or more second parameters.

Description

[Technical Field]

[0001] Cross-reference of related applications

[0001] This disclosure claims the benefit of priority to U.S. Provisional Patent Application No. 62 / 903,251, filed September 20, 2019, which is incorporated herein by reference in its entirety.

[0002] Technical field

[0002] This disclosure generally relates to video processing, and more particularly to methods and systems for processing video content together with quantization parameters. [Background technology]

[0003] background

[0003] Video is a set of static pictures (or "frames") that capture visual information. To reduce memory and transmission bandwidth, video can be compressed before storage or transmission and decompressed before display. The compression process is usually called encoding, and the decompression process is usually called decoding. Most commonly, there are various video coding formats that use standardized video coding techniques based on prediction, transformation, quantization, entropy coding, and in-loop filtering. Video coding standards such as the High Efficiency Video Coding (HEVC / H.265) standard, Versatile Video Coding (VVC / H.266) standard, and AVS standard have been developed by standardizing organizations, specifying particular video coding formats. As more advanced video coding techniques are adopted in video standards, the coding efficiency of new video coding standards increases. [Overview of the Initiative] [Means for solving the problem]

[0004] Summary of this disclosure

[0004] Embodiments of the present disclosure provide a method implemented by a computer for processing video content, including receiving a bitstream including encoded video data, determining a first parameter of an encoded block, determining one or more second parameters related to a delta quantization parameter (QP) value or a chroma QP offset value according to the first parameter, and determining at least one of the delta QP value or the chroma QP offset value according to one or more second parameters.

[0005]

[0005] Embodiments of the present disclosure also provide a system for processing video content, including a memory storing a set of instructions and at least one processor. The at least one processor is configured to execute the set of instructions to cause the system to receive a bitstream including encoded video data, determine a first parameter of an encoded block, determine one or more second parameters related to a delta quantization parameter (QP) value or a chroma QP offset value according to the first parameter, and determine at least one of the delta QP value or the chroma QP offset value according to one or more second parameters.

[0006]

[0006] Embodiments of the present disclosure also provide a non - transient computer - readable medium storing instructions executable by at least one processor of a computer system. Executing the instructions causes the computer system to receive a bitstream including encoded video data, determine a first parameter of an encoded block, determine one or more second parameters related to a delta quantization parameter (QP) value or a chroma QP offset value according to the first parameter, and cause the computer system to perform a method including determining at least one of the delta QP value or the chroma QP offset value according to one or more second parameters.

[0007] Brief Description of the Drawings

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

[0008] [Figure 1]

[0008] An exemplary video sequence structure consistent with an embodiment of the present disclosure is shown. [Figure 2A]

[0009] A schematic diagram of an exemplary encoding process for a hybrid video encoding system consistent with embodiments of this disclosure is shown. [Figure 2B]

[0010] A schematic diagram of another exemplary encoding process for a hybrid video encoding system consistent with embodiments of this disclosure is shown. [Figure 3A]

[0011] A schematic diagram illustrating an exemplary decoding process of a hybrid video encoding system consistent with embodiments of this disclosure is shown. [Figure 3B]

[0012] A schematic diagram of another exemplary decoding process for a hybrid video encoding system consistent with embodiments of this disclosure is shown. [Figure 4]

[0013] This is a block diagram of an exemplary device for encoding or decoding video, consistent with embodiments of the present disclosure. [Figure 5]

[0014] An example of a picture parameter set (PPS) for coded unit (CU) delta quantization parameters (QP) consistent with embodiments of this disclosure is shown. [Figure 6A]

[0015] An example of coded tree-level syntax for CU delta QP consistent with embodiments of this disclosure is shown. [Figure 6B]

[0015] An example of coded tree-level syntax for CU delta QP consistent with embodiments of the present disclosure is shown. [Figure 6C]

[0015] An example of coded tree-level syntax for CU delta QP consistent with embodiments of the present disclosure is shown. [Figure 7A]

[0016] An example of a conversion unit level syntax for CU delta QP consistent with embodiments of this disclosure is shown. [Figure 7B]

[0016] An example of a conversion unit level syntax for CU delta QP consistent with embodiments of the present disclosure is shown. [Figure 7C]

[0016] An example of a conversion unit level syntax for CU delta QP consistent with embodiments of the present disclosure is shown. [Figure 8]

[0017] An example of slice header syntax consistent with the embodiments of this disclosure is shown below. [Figure 9]

[0018] Another example of slice header syntax consistent with embodiments of this disclosure is shown below. [Figure 10]

[0019] Here is yet another example of slice header syntax consistent with embodiments of this disclosure. [Figure 11]

[0020] Another example of picture header syntax consistent with embodiments of this disclosure is shown below. [Figure 12]

[0021] An example of PPS syntax for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv that conforms to embodiments of this disclosure is shown. [Figure 13]

[0022] An example of slice header syntax for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv that conforms to embodiments of this disclosure is shown. [Figure 14]

[0023] An example of syntax for sps_max_mtt_depth_luma that conforms to embodiments of this disclosure is shown below. [Figure 15]

[0024] An example of syntax for pps_max_mtt_depth_luma that conforms to embodiments of this disclosure is shown below. [Figure 16]

[0025] An example of SPS syntax for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv that conforms to embodiments of this disclosure is shown. [Figure 17]

[0026] An example of slice header syntax for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv that conforms to embodiments of this disclosure is shown. [Figure 18]

[0027] An example of syntax for sps_max_mtt_depth_luma that conforms to embodiments of this disclosure is shown below. [Figure 19]

[0028] Another example of syntax for sps_max_mtt_depth_luma that conforms to embodiments of this disclosure is shown. [Figure 20]

[0029] An example of syntax for pps_max_mtt_depth_luma that conforms to embodiments of this disclosure is shown below. [Figure 21]

[0030] This is a flowchart illustrating an exemplary computer-implemented method for processing video content, consistent with embodiments of the present disclosure. [Modes for carrying out the invention]

[0009]

[0031] Video encoding systems are often used to compress digital video signals, for example, to reduce the memory space consumed or the amount of transmission bandwidth associated with such signals. In various applications of video compression such as online video streaming, video conferencing, or video surveillance, as the popularity of high-definition (HD) video (e.g., with a resolution of 1920 x 1080 pixels) increases, there is a continuous need to develop video encoding tools that can improve the efficiency of video data compression.

[0010]

[0032] For example, video surveillance applications are being used more and more widely in many application scenarios (e.g., security, traffic, environmental monitoring, etc.), and the number and resolution of surveillance devices are rapidly increasing. Many video surveillance application scenarios choose to provide users with HD video in order to capture more information, and HD video has more pixels per frame in order to capture such information. However, HD video bitstreams can have high bitrates, which require high bandwidth for transmission and large space for storage. For example, a surveillance video stream with an average resolution of 1920 x 1080 may require as much as 4 Mbps of bandwidth for real-time transmission. Furthermore, video surveillance generally involves continuous monitoring, which can be a significant challenge for storage systems when storing video data. Therefore, the demand for high bandwidth and large storage space of HD video is the main limiting factor for the large-scale deployment of HD video in video surveillance.

[0011]

[0033] An image is a set of still pictures (or "frames") arranged in chronological order to store visual information. An image capture device (e.g., a camera) can be used to capture and store these pictures in chronological order, and an image 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. Furthermore, in some applications, for surveillance, conferences, or live broadcasts, the image capture device can transmit the captured image to an image playback device (e.g., a computer with a monitor) in real time.

[0012]

[0034] To reduce the memory space and transmission bandwidth required by such applications, video can be compressed before storage and transmission, and decompressed before display. This compression and decompression can be implemented 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 can be collectively called a "codec." Encoders and decoders can be implemented as various appropriate hardware, software, or a combination thereof. For example, a hardware implementation of an encoder and decoder may include circuits such as one or more microprocessors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), rewritable gate arrays (FPGAs), discrete logic, or any combination thereof. Software implementations may include program code, computer executable instructions, firmware, or algorithms or processes implemented by any suitable computer fixed within computer-readable media. Video compression and decompression can be implemented by various algorithms or standards such as MPEG-1, MPEG-2, MPEG-4, and the H.26x series. In some applications, a codec can decompress video from a first encoding standard and recompress the decompressed video using a second encoding standard; in this case, the codec may be called a "transcoder."

[0013]

[0035] A video encoding process can identify and retain useful information that can be used to reconstruct a picture, while ignoring information that is not important for reconstruction. If the ignored, non-essential information cannot be fully reconstructed, such an encoding process can be called "lossy." Otherwise, such an encoding process can be called "lossy." Most encoding processes are lossy, which is a trade-off to reduce the required memory space and transmission bandwidth.

[0014]

[0036] Useful information in an encoded picture (referred to as the "current picture") includes changes relative to a reference picture (e.g., a previously encoded and reconstructed picture). Such changes can include changes in pixel position, brightness, or color, of which position changes are 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.

[0015]

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

[0016]

[0038] As mentioned earlier, video surveillance using HD video faces the challenge of high bandwidth and large storage requirements. To address this challenge, the bitrate of encoded video can be reduced. Of I-pictures, P-pictures, and B-pictures, I-pictures have the highest bitrate. Since the background of most surveillance video is almost static, one way to reduce the overall bitrate of encoded video may be to use fewer I-pictures for encoding the video.

[0017]

[0039] However, since I-pictures are generally not the primary element in encoded video, improvements that reduce I-picture usage may be negligible. For example, in a typical video bitstream, the ratio of I-pictures, B-pictures, and P-pictures may be 1:20:9, with I-pictures accounting for less than 10% of the total bitrate. In other words, in such an example, removing all I-pictures may only reduce the bitrate by 10%.

[0018]

[0040] This disclosure provides methods, apparatus, and systems for processing video content using Adaptive Resolution Change (ARC). Unlike phase rounding, which results in inaccurate phases, embodiments of this disclosure provide a pixel refinement process based on fixed-phase interpolation to reduce algorithmic and hardware complexity while maintaining accuracy.

[0019]

[0041] Figure 1 shows the structure of an example of a video sequence 100 that conforms to an embodiment of the present disclosure. The video sequence 100 may be live broadcast video or captured and archived video. The video 100 may be real video, computer-generated video (e.g., The video sequence 100 may be computer game footage or a combination thereof (for example, real-world footage with augmented reality effects). The video sequence 100 may be input from a video acquisition device (for example, a camera), a video archive containing previously captured footage (for example, video files stored in a memory device), or a video feed interface for receiving video from a video content provider (for example, a video broadcast transceiver).

[0020]

[0042] As shown in Figure 1, the video sequence 100 may include a series of pictures arranged in time along a timeline, including pictures 102, 104, 106, and 108. Pictures 102-106 are sequential, with more pictures between picture 106 and picture 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 as indicated by the arrow, its reference picture is picture 102. Picture 106 is a B picture, and as indicated by the arrow, its reference pictures are pictures 104 and 108. In some embodiments, the reference picture of a picture (e.g., picture 104) may not be immediately before or after that picture. For example, the reference picture of picture 104 may be a picture preceding picture 102. It should be noted 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.

[0021]

[0043] Typically, a video codec does not encode or decode the entire picture at once, because such a task is computationally complex. Rather, a video codec can divide the picture into basic segments and encode or decode the picture segment by segment. In this disclosure, such basic segments are referred to as basic processing units ("BPUs"). For example, structure 110 in Figure 1 shows an example of the structure of a picture (e.g., any of pictures 102-108) in video sequence 100. In structure 110, the picture is divided into 4x4 basic processing units, the boundaries of which are indicated by dashed lines. In some embodiments, basic processing units may be referred to as "macroblocks" in some video encoding standards (e.g., the MPEG family, H.261, H.263, or H.264 / AVC) and as "encoded tree units" ("CTUs") in some other video encoding standards (e.g., H.265 / HEVC or H.266 / VVC). Basic processing units, such as 128x128, 64x64, 32x32, 16x16, 4x8, 16x32, or any arbitrary shape and size of pixels, can have variable sizes within a picture. The size and shape of the basic processing unit can be selected for a picture based on a balance between coding efficiency and the level of detail to be maintained within the basic processing unit.

[0022]

[0044] A basic processing unit can be a logical unit that may contain various types of video data stored in computer memory (e.g., in a video frame buffer). For example, a basic processing unit of a color picture may include a luminance component (Y) representing achromatic luminance information, one or more chroma components (e.g., Cb and Cr) representing color information, and associated syntactic elements of the basic processing unit in which the lumina and chroma components may have the same size. In some video encoding standards (e.g., H.265 / HEVC or H.266 / VVC), the lumina and chroma components may be called a "coding tree block" ("CTB"). Any operation performed on a basic processing unit can be repeated on its lumina and chroma components, respectively.

[0023]

[0045] Video encoding involves multiple operational stages, examples of which are detailed in Figures 2A-2B and 3A-3B. For each stage, the size of the basic processing unit may still be too large to process and can therefore be further divided into segments referred to in this disclosure as “basic processing subunits.” In some embodiments, the basic processing subunits are used for certain video encoding standards (e.g., MPEG family, H.261, H.263, or H.264 / AVC). A basic processing subunit can be called a “block” within the standard, or a “coded unit” ("CU") within some other video encoding standards (e.g., H.265 / HEVC or H.266 / VVC). A basic processing subunit can 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 can contain various types of video data (e.g., Y, Cb, Cr, and related syntactic 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. It should be noted that such divisions may be performed at further levels as processing needs require. It should also be noted that various stages may divide the basic processing unit using various methods.

[0024]

[0046] For example, during the mode determination stage (one example of which is detailed in Figure 2B), the encoder can determine which prediction mode (e.g., intra-picture prediction or inter-picture prediction) to use for a basic processing unit, and the basic processing unit 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 H.265 / HEVC or H.266 / VVC) and determine the type of prediction for each basic processing subunit.

[0025]

[0047] In another example (an example of which is detailed in Figure 2A), during the prediction phase, the encoder can perform prediction operations at the level of a basic processing subunit (e.g., CU). However, in some cases, the basic processing subunit may still be too large to process. The encoder can further divide the basic processing subunit into smaller segments (e.g., called "prediction blocks" or "PBs" in H.265 / HEVC or H.266 / VVC) and perform prediction operations at that level.

[0026]

[0048] In another example (an example of which is detailed in Figure 2A), during the conversion stage, the encoder can perform conversion operations on residual subunits (e.g., CUs). However, in some cases, the subunit may still be too large to process. The encoder can further divide the subunit into smaller segments (e.g., called "conversion blocks" or "TBs" in H.265 / HEVC or H.266 / VVC) and perform conversion operations at that level. It should be noted that the division method of the same subunit may differ between the prediction and conversion stages. For example, in H.265 / HEVC or H.266 / VVC, the prediction and conversion blocks of the same CU may have different sizes and numbers.

[0027]

[0049] In the structure 110 of Figure 1, the basic processing unit 112 is further divided into 3x3 basic processing subunits, with the boundaries indicated by dotted lines. Different basic processing units of the same picture can be divided into basic processing subunits in different ways.

[0028]

[0050] In some implementations, to provide parallel processing and error tolerance for video encoding and decoding, a picture can be divided into processing regions, thereby ensuring 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 different regions of the picture in parallel, thus increasing the efficiency of encoding. Furthermore, if data in a region is corrupted during processing or lost during network transmission, the codec can correctly encode or decode other regions of the same picture without relying on the corrupted or lost data, thus providing error tolerance. Some video encoding standards allow a picture to be divided into different types of regions. For example, H.265 / HEVC and H.266 / VVC offer two types of regions: "slice" and "tile". It should also be noted that Kucha may have various methods for dividing a picture into different areas.

[0029]

[0051] For example, in Figure 1, structure 110 is divided into three regions 114, 116, and 118, with their boundaries shown as solid lines within structure 110. Region 114 contains four basic processing units. Regions 116 and 118 each contain six basic processing units. It should be noted that the basic processing units, basic sub-units, and regions of structure 110 in Figure 1 are merely examples, and this disclosure does not limit its embodiments.

[0030]

[0052] Figure 2A shows a schematic diagram of an example of an encoding process 200A consistent with embodiments of the present disclosure. The encoder can encode a video sequence 202 into a video bitstream 228 according to process 200A. Similar to video sequence 100 in Figure 1, video sequence 202 may include a set of pictures (referred to as “original pictures”) arranged in chronological order. Similar to structure 110 in Figure 1, each original picture in video sequence 202 may be divided by the encoder into a basic processing unit, a basic processing subunit, or a region for processing. In some embodiments, the encoder can execute process 200A at the level of a basic processing unit for each original picture in video sequence 202. For example, the encoder can execute process 200A in an iterative manner, and the encoder can encode a basic processing unit in a single iteration of process 200A. In some embodiments, the encoder can execute process 200A in parallel for regions of each original picture in video sequence 202 (e.g., regions 114-118).

[0031]

[0053] In Figure 2A, the encoder can feed the basic processing unit of the original picture of the video sequence 202 (referred to as the "original BPU") to the prediction stage 204 to generate the predicted data 206 and the predicted BPU 208. The encoder can subtract the predicted BPU 208 from the original BPU to generate the residual BPU 210. The encoder can feed the residual BPU 210 to the conversion stage 212 and the quantization stage 214 to generate the quantized conversion coefficients 216. The encoder can feed the predicted data 206 and the quantized conversion coefficients 216 to the binary encoding stage 226 to generate the video bitstream 228. Components 202, 204, 206, 208, 210, 212, 214, 216, 226, and 228 can be referred to as the "forward path". During process 200A, after the quantization stage 214, the encoder can feed the quantized transformation coefficients 216 to the inverse quantization stage 218 and the inverse transformation stage 220 to generate a reconstructed residual BPU 222. The encoder can then use the reconstructed residual BPU 222, along with the predicted BPU 208, to generate a prediction criterion 224 to be used in the prediction stage 204 of the next iteration of process 200A. Components 218, 220, 222, and 224 of process 200A can be referred to as the “reconstruction path”. The reconstruction path may be used to ensure that both the encoder and the decoder use the same reference data for prediction.

[0032]

[0054] The encoder can iteratively perform process 200A to encode each original BPU of the original picture (in the forward path) and generate a predicted criterion 224 for encoding the next original BPU of the original picture (in the reconstruction path). After encoding all the original BPUs of the original picture, the encoder can proceed to encode the next picture in the video sequence 202.

[0033]

[0055] Referring to process 200A, the encoder may receive a video sequence 202 generated by a video acquisition device (e.g., a camera). As used herein, the term “receive” may mean receiving, inputting, acquiring, retrieving, obtaining, reading, accessing, or any action in any manner for the purpose of inputting data.

[0034]

[0056] In prediction stage 204, in the current iteration, the encoder receives the original BPU and prediction criterion 224 and can perform a prediction operation to generate prediction data 206 and the predicted BPU 208. The prediction criterion 224 may be generated from the reconstruction path of the previous iteration in process 200A. The purpose of prediction stage 204 is to reduce information redundancy by extracting prediction data 206, which can be used to reconstruct the original BPU as the predicted BPU 208 from the prediction data 206 and prediction criterion 224.

[0035]

[0057] Ideally, the predicted BPU208 can be identical to the original BPU. However, due to less-than-ideal prediction and reconstruction operations, the predicted BPU208 is generally slightly different from the original BPU. To record such differences, the encoder can generate the predicted BPU208 and then subtract it from the original BPU to produce the residual BPU210. For example, the encoder can subtract the pixel values ​​(e.g., grayscale or RGB values) of the predicted BPU208 from the corresponding pixel values ​​of the original BPU. As a result of such subtraction between the corresponding pixels of the original BPU and the predicted BPU208, each pixel of the residual BPU210 may have a residual value. Compared to the original BPU, the predicted data 206 and residual BPU210 may have fewer bits, but they can be used to reconstruct the original BPU without significantly compromising quality.

[0036]

[0058] To further compress the residual BPU 210, in the transformation step 212, the encoder can reduce the spatial redundancy of the residual BPU 210 by decomposing it into a set of two-dimensional "basis patterns," each basis pattern being associated with a "transformation coefficient." The basis patterns can have the same size (e.g., the size of the residual BPU 210). Each basis pattern can represent the variation frequency (e.g., luminance variation frequency) component of the residual BPU 210. None of the basis patterns can be reconstructed from any combination (e.g., a linear combination) of any other basis pattern. In other words, the decomposition can decompose the variation of the residual BPU 210 into the frequency domain. Such decomposition is analogous to the discrete Fourier transform of a function, the basis patterns are analogous to the basis functions of the discrete Fourier transform (e.g., trigonometric functions), and the transformation coefficients are analogous to the coefficients associated with the basis functions.

[0037]

[0059] Various transformation algorithms can use various basis patterns. For example, various transformation algorithms can be used in transformation stage 212, such as discrete cosine transform and discrete sine transform. The transformation in transformation stage 212 is reversible. That is, the encoder can reconstruct the residual BPU 210 by the inverse operation of the transformation (called the "inverse transform"). For example, to reconstruct the pixels of the residual BPU 210, the inverse transform may be to multiply the values ​​of the corresponding pixels in the basis pattern by the respective coefficients in question, and then add the products to obtain a weighted sum. In the video coding standard, both the encoder and the decoder can use the same transformation algorithm (and therefore the same basis pattern). Therefore, the encoder can record only the transformation coefficients, and the decoder can reconstruct the residual BPU 210 from the transformation coefficients without receiving the basis pattern from the encoder. The transformation coefficients may have fewer bits than the residual BPU 210, but these transformation coefficients can be used to reconstruct the residual BPU 210 without significantly degrading the quality. Therefore, the residual BPU210 is further compressed.

[0038]

[0060] The encoder can further compress the conversion coefficients in the quantization stage 214. In the conversion process, various basis patterns can represent various fluctuation frequencies (e.g., luminance fluctuation frequencies). Since the human eye is generally good at recognizing low-frequency fluctuations, the encoder can ignore high-frequency fluctuation information without causing significant quality degradation during decoding. For example, in the quantization stage 214, the encoder quantizes by dividing each conversion coefficient by an integer value (called a "quantization parameter") and rounding the quotient to its nearest neighbor. The resulting transformation coefficients 216 can be generated. After this operation, some of the transformation coefficients of the high-frequency basis pattern can be converted to zero, and the transformation coefficients of the low-frequency basis pattern can be converted to smaller integers. The encoder can ignore the zero-value quantized transformation coefficients 216, thereby further compressing the transformation coefficients. The quantization process is also reversible, and the quantized transformation coefficients 216 can be reconstructed into transformation coefficients in the inverse operation of quantization (called "inverse quantization").

[0039]

[0061] Because the encoder ignores the remainder of such division in the rounding operation, the quantization stage 214 may be irreversible. Typically, the quantization stage 214 can contribute the greatest information loss in process 200A. The greater the information loss, the fewer bits the quantized conversion coefficients 216 may require. To obtain various levels of information loss, the encoder can use various values ​​of the quantization parameters or any other parameters of the quantization process.

[0040]

[0062] In the binary encoding stage 226, the encoder can encode the predicted data 206 and the quantized conversion coefficients 216 using a binary encoding technique such as entropy encoding, variable-length encoding, arithmetic encoding, Huffman encoding, context-adaptive binary arithmetic encoding, or any other lossless or lossy compression algorithm. In some embodiments, in addition to the predicted data 206 and the quantized conversion coefficients 216, the encoder can encode other information in the binary encoding stage 226, such as the prediction mode used in the prediction stage 204, parameters of the prediction operation, the type of transformation in the transformation stage 212, parameters of the quantization process (e.g., quantization parameters), and encoder control parameters (e.g., bitrate control parameters). The encoder can use the output data from the binary encoding stage 226 to generate a video bitstream 228. In some embodiments, the video bitstream 228 can be further packetized for network transmission.

[0041]

[0063] Referring to the reconstruction path of process 200A, in the inverse quantization stage 218, the encoder can perform inverse quantization on the quantized transformation coefficients 216 to generate reconstructed transformation coefficients. In the inverse transformation stage 220, the encoder can generate a reconstructed residual BPU 222 based on the reconstructed transformation coefficients. The encoder can then use the reconstructed residual BPU 222, along with the predicted BPU 208, to generate a prediction criterion 224 to be used in the next iteration of process 200A.

[0042]

[0064] It should be noted that other variations of process 200A can be used to encode the video sequence 202. In some embodiments, the encoder may perform the steps of process 200A in a different order. In some embodiments, one or more steps of process 200A may be combined into a single step. In some embodiments, a single step of process 200A may be divided into multiple steps. For example, the transformation step 212 and the quantization step 214 may be combined into a single step. In some embodiments, process 200A may include additional steps. In some embodiments, process 200A may omit one or more steps in Figure 2A.

[0043]

[0065] Figure 2B shows a schematic diagram of another example 200B of the encoding process conforming to embodiments of the present disclosure. Process 200B may be modified from process 200A. For example, process 200B may be used by an encoder conforming to a hybrid video encoding standard (e.g., the H.26x series). Compared to process 200A, the forward path of process 200B further includes a mode determination stage 230 and divides the prediction stage 204 into a spatial prediction stage 2042 and a temporal prediction stage 2044. The reconstruction path of process 200B additionally includes a loop filter stage 232 and a buffer 234.

[0044]

[0066] Generally, prediction techniques can be classified into two types: spatial prediction and temporal prediction. Spatial prediction (e.g., intra-picture prediction or "intra-prediction") can use one or more already coded pixels of neighboring BPUs within the same picture to predict the current BPU. That is, the prediction criterion 224 in spatial prediction may include neighboring BPUs. Spatial prediction can reduce the inherent spatial redundancy of a picture. Temporal prediction (e.g., inter-picture prediction or "inter-prediction") can use one or more already coded regions of a picture to predict the current BPU. That is, the prediction criterion 224 in temporal prediction may include coded pictures. Temporal prediction can reduce the inherent temporal redundancy of a picture.

[0045]

[0067] Referring to process 200B, in the forward path, the encoder performs prediction operations in the spatial prediction stage 2042 and the temporal prediction stage 2044. For example, in the spatial prediction stage 2042, the encoder can perform intra-prediction. With respect to the original BPU of the picture being encoded, the prediction criterion 224 may include one or more neighboring BPUs within the same picture that are encoded (in the forward path) and reconstructed (in the reconstruction path). The encoder can generate a predicted BPU 208 by extrapolating neighboring BPUs. Extrapolation techniques may include, for example, linear extrapolation or linear interpolation, polynomial extrapolation or polynomial interpolation, etc. In some embodiments, the encoder can perform extrapolation at the pixel level, for example, by extrapolating the values ​​of the corresponding pixels for each pixel of the predicted BPU 208. The adjacent BPU used for extrapolation may be located relative to the original BPU from various directions, such as vertically (e.g., above the original BPU), horizontally (e.g., to the left of the original BPU), diagonally (e.g., below left, below right, above left, or above right of the original BPU), or in any direction specified within the video encoding standard used. In intra-prediction, the prediction data 206 may include, for example, the location (e.g., coordinates) of the adjacent BPU used, the size of the adjacent BPU used, the extrapolation parameters, and the orientation of the adjacent BPU used relative to the original BPU.

[0046]

[0068] In another example, during the temporal prediction stage 2044, the encoder can perform interpretation. With respect to the original BPU of the current picture, the prediction criterion 224 may include one or more pictures (referred to as "reference pictures") that have been encoded (in the forward path) and reconstructed (in the reconstruction path). In some embodiments, the reference pictures may be encoded and reconstructed for each BPU. For example, the encoder can generate reconstructed BPUs by adding the reconstructed residual BPU 222 to the predicted BPU 208. Once all reconstructed BPUs of the same picture have been generated, the encoder can generate a reconstructed picture as a reference picture. The encoder can perform a "motion estimation" operation to search for matching regions within the range of the reference picture (referred to as a "search window"). The location of the search window in the reference picture can be determined based on the location of the original BPU in the current picture. For example, the search window can be centered at a location in the reference picture that has the same coordinates as the original BPU in the current picture and can be extended over a predetermined distance. The encoder searches within the search window for a region similar to the original BPU (e.g., PEL recursive algorithm, block matching algorithm) By identifying (for example, by using), the encoder can determine that region is a match region. The match region may have different dimensions from the original BPU (e.g., smaller, equal, larger, or different shape). Since the reference picture and the current picture are separated in time in the timeline (for example, as shown in Figure 1), the match region can be considered to "move" to the position of the original BPU over time. The encoder can record the direction and distance of such movement as a "motion vector". If multiple reference pictures are used (for example, picture 106 in Figure 1), the encoder can look up a match region for each reference picture and determine its associated motion vector. In some embodiments, the encoder can assign weights to the pixel values ​​of the match region for each matching reference picture.

[0047]

[0069] Motion estimation can be used to identify various types of motion, such as translation, rotation, and scaling. In interpretation, the prediction data 206 may include, for example, the location of the matching region (e.g., coordinates), motion vectors associated with the matching region, the number of reference pictures, and weights associated with the reference pictures.

[0048]

[0070] To generate the predicted BPU 208, the encoder can perform a “motion compensation” operation. Motion compensation can be used to reconstruct the predicted BPU 208 based on prediction data 206 (e.g., motion vectors) and prediction criteria 224. For example, the encoder can move the matching region of a reference picture according to the motion vector, within which the encoder can predict the original BPU of the current picture. If multiple reference pictures are used (e.g., picture 106 in Figure 1), the encoder can move the matching region of each reference picture according to the individual motion vectors and average the pixel values ​​of the matching region. In some embodiments, if the encoder assigns weights to the pixel values ​​of the matching region of each matching reference picture, the encoder can add up the weighted sum of the pixel values ​​of the moved matching region.

[0049]

[0071] In some embodiments, interpretation can be unidirectional or bidirectional. Unidirectional interpretation can use one or more reference pictures that are in the same temporal direction relative to the current picture. For example, picture 104 in Figure 1 is a unidirectional interpretation picture in which the reference picture (i.e., picture 102) precedes picture 104. Bidirectional interpretation can use one or more reference pictures that are in both temporal directions relative to the current picture. For example, picture 106 in Figure 1 is a bidirectional interpretation picture in which the reference pictures (i.e., pictures 104 and 108) are in both temporal directions relative to picture 104.

[0050]

[0072] Continuing to refer to the forward path of process 200B, after the spatial prediction stage 2042 and the temporal prediction stage 2044, in the mode determination stage 230, the encoder may select a prediction mode (e.g., one of intra-prediction or inter-prediction) for the current iteration of process 200B. For example, the encoder may perform a rate distortion optimization technique, in which the encoder may select a prediction mode to minimize the value of the cost function, depending on the bit rate of the candidate prediction mode and the distortion of the reconstructed reference picture under the candidate prediction mode. Depending on the selected prediction mode, the encoder may generate the corresponding predicted BPU 208 and predicted data 206.

[0051]

[0073] In the reconstruction path of process 200B, if intra-prediction mode is selected in the forward path, after generating prediction criterion 224 (e.g., the current BPU being encoded and reconstructed within the current picture), the encoder can directly feed prediction criterion 224 to spatial prediction stage 2042 for later use (e.g., to extrapolate the next BPU of the current picture). If inter-prediction mode is selected in the forward path, after generating prediction criterion 224 (e.g., the current picture with all BPUs encoded and reconstructed), the encoder can feed prediction criterion 224 to loop filtering stage 232, where the encoder can apply loop filtering to prediction criterion 224 to reduce or eliminate distortions (e.g., blocking artifacts) caused by inter-prediction. Various loop filtering techniques can be applied in loop filtering stage 232, such as deblocking, sample-adaptive offset, and adaptive loop filtering. Loop-filtered reference pictures can be stored in buffer 234 (or “decoded picture buffer”) for later use (for example, to be used as interpredictive reference pictures for future pictures in video sequence 202). The encoder can store one or more reference pictures in buffer 234 for use in the temporal prediction stage 2044. In some embodiments, the encoder The parameters of the loop filter (e.g., the strength of the loop filter) can be encoded in the binary encoding step 226, along with the quantized transformation coefficients 216, the prediction data 206, and other information.

[0052]

[0074] Figure 3A shows a schematic diagram of an example of a decoding process 300A that conforms to an embodiment of the present disclosure. Process 300A may be a decompression process corresponding to the compression process 200A in Figure 2A. In some embodiments, process 300A may be similar to the reconstruction path of process 200A. The decoder can decode the video bitstream 228 into a video stream 304 according to process 300A. The video stream 304 may be very similar to the video sequence 202. However, due to information loss in the compression and decompression processes (e.g., the quantization stage 214 in Figures 2A-2B), the video stream 304 is generally not identical to the video sequence 202. Similar to processes 200A and 200B in Figures 2A-2B, the decoder can execute process 300A at the level of basic processing units (BPUs) for each picture encoded in the video bitstream 228. For example, the decoder can execute process 300A in an iterative manner, and the decoder can decode a basic processing unit in one iteration of process 300A. In some embodiments, the decoder can execute process 300A in parallel for each region of picture (e.g., regions 114-118) to be encoded within the video bitstream 228.

[0053]

[0075] In Figure 3A, the decoder can feed a portion of the video bitstream 228 associated with the basic processing unit of the encoded picture (referred to as the "encoded BPU") to the binary decoding stage 302. In the binary decoding stage 302, the decoder can decode that portion into prediction data 206 and quantized transformation coefficients 216. The decoder can feed the quantized transformation coefficients 216 to the inverse quantization stage 218 and the inverse transformation stage 220 to generate the reconstructed residual BPU 222. The decoder can feed the prediction data 206 to the prediction stage 204 to generate the predicted BPU 208. The decoder can add the reconstructed residual BPU 222 to the predicted BPU 208 to generate the predicted criterion 224. In some embodiments, the predicted criterion 224 may be stored in a buffer (e.g., a decoded picture buffer in computer memory). The decoder can feed the predicted criterion 224 to the prediction stage 204 for performing a prediction operation in the next iteration of process 300A.

[0054]

[0076] The decoder can iteratively perform process 300A to decode each encoded BPU of the encoded picture and generate a predicted criterion 224 for encoding the next encoded BPU of the encoded picture. After decoding all encoded BPUs of the encoded picture, the decoder can output the picture to the video stream 304 for display and proceed to decode the next encoded picture in the video bitstream 228.

[0055]

[0077] In the binary decoding stage 302, the decoder can perform the inverse operation of the binary encoding technique used by the encoder (e.g., entropy encoding, variable-length encoding, arithmetic encoding, Huffman encoding, context-adaptive binary arithmetic encoding, or any other arbitrary lossless compression algorithm). In some embodiments, in addition to the prediction data 206 and the quantized conversion coefficients 216, the decoder can decode other information in the binary decoding stage 302, such as the prediction mode, parameters of the prediction operation, type of conversion, parameters of the quantization process (e.g., quantization parameters), and encoder control parameters (e.g., bitrate control parameters). In some embodiments, if the video bitstream 228 is transmitted in packets over the network, the decoder can depacketize the video bitstream 228 and then feed it to the binary decoding stage 302.

[0056]

[0078] Figure 3B shows a schematic diagram of another example 300B of the decoding process conforming to embodiments of the present disclosure. Process 300B may be modified from process 300A. For example, process 300B may be used by a decoder conforming to a hybrid video coding standard (e.g., the H.26x series). Compared to process 300A, process 300B further divides the prediction stage 204 into a spatial prediction stage 2042 and a temporal prediction stage 2044, and additionally includes a loop filter stage 232 and a buffer 234.

[0057]

[0079] In process 300B, with respect to the encoded basic processing unit ("current BPU") of the encoded picture being decoded ("current picture"), the prediction data 206 decoded by the decoder from binary decoding stage 302 may contain various types of data depending on which prediction mode was used by the encoder to encode the current BPU. For example, if intra-prediction is used by the encoder to encode the current BPU, the prediction data 206 may include prediction mode indicators (e.g., flag values) indicating the intra-prediction, parameters of the intra-prediction operation, etc. Parameters of the intra-prediction operation may include, for example, the location (e.g., coordinates) of one or more adjacent BPUs used as a reference, the size of the adjacent BPU, extrapolation parameters, the orientation of the adjacent BPU relative to the original BPU, etc. In another example, if inter-prediction is used by the encoder to encode the current BPU, the prediction data 206 may include prediction mode indicators (e.g., flag values) indicating the inter-prediction, parameters of the inter-prediction operation, etc. The parameters for the interpretation operation may include, for example, the number of reference pictures associated with the current BPU, the weights associated with each reference picture, the location (e.g., coordinates) of one or more matching regions within each reference picture, and one or more motion vectors associated with each matching region.

[0058]

[0080] Based on the prediction mode indicator, the decoder can decide whether to perform a spatial prediction (e.g., intra-prediction) in the spatial prediction stage 2042 or a temporal prediction (e.g., inter-prediction) in the temporal prediction stage 2044. Details of the execution of such spatial or temporal predictions are shown in Figure 2B and will not be repeated below. After performing such spatial or temporal predictions, the decoder can generate the predicted BPU 208. As shown in Figure 3A, the decoder can generate the prediction criterion 224 by adding the predicted BPU 208 and the reconstructed residual BPU 222.

[0059]

[0081] In process 300B, the decoder can feed the predicted criterion 224 to the spatial prediction stage 2042 or the temporal prediction stage 2044 for performing a prediction operation within the next iteration of process 300B. For example, if the current BPU is decoded using intra-prediction in spatial prediction stage 2042, after generating the prediction criterion 224 (e.g., the decoded current BPU), the decoder can directly feed the prediction criterion 224 to spatial prediction stage 2042 for later use (e.g., to extrapolate the next BPU of the current picture). If the current BPU is decoded using inter-prediction in temporal prediction stage 2044, after generating the prediction criterion 224 (e.g., the reference picture from which all BPUs have been decoded), the encoder can feed the prediction criterion 224 to the loop filter stage 232 to reduce or eliminate distortion (e.g., blocking artifacts). The decoder can apply a loop filter to the prediction criterion 224 in the manner described in Figure 2B. The loop-filtered reference picture can be stored in buffer 234 (e.g., a decoded picture buffer in computer memory) for later use (e.g., for use as an inter-prediction reference picture for future encoded pictures of the video bitstream 228). The decoder may store one or more reference pictures in buffer 234 for use in the temporal prediction stage 2044. In some embodiments, if the prediction mode indicator of the prediction data 206 indicates that inter-prediction was used to encode the current BPU, the prediction data may further include loop filter parameters (e.g., loop filter strength).

[0060]

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

[0061]

[0083] The device 400 may also include a memory 404 configured to store data (e.g., sets of instructions, computer code, intermediate data, etc.). For example, as shown in Figure 4, the stored data may include program instructions (e.g., program instructions for implementing stages within processes 200A, 200B, 300A, or 300B) and processing data (e.g., video sequence 202, video bitstream 228, or video stream 304). The processor 402 can access the program instructions and processing data (e.g., via the bus 410) and execute the program instructions to perform operations or processing on the processing data. The memory 404 may include a high-speed random-access storage device or a non-volatile storage device. In some embodiments, the memory 404 may include any combination of any number of random-access memories (RAM), read-only memories (ROM), optical disks, magnetic disks, hard drives, solid-state drives, flash drives, security digital (SD) cards, memory sticks, CompactFlash® (CF) cards, etc. Memory 404 can also be a group of memories (not shown in Figure 4) that are grouped together as a single logical component.

[0062]

[0084] Buses 410, such as an internal bus (e.g., a CPU memory bus) or an external bus (e.g., a universal serial bus port, a peripheral component interconnection express port), may be communication devices that transfer data between components within the device 400.

[0063]

[0085] To simplify the explanation without causing ambiguity, the processor 402 and other data processing circuits are collectively referred to as the “data processing circuits” in this disclosure. The data processing circuits may be implemented entirely in hardware or as a combination of software, hardware, or firmware. In addition, the data processing circuits may be a single, independent module or may be fully or partially integrated into any other component of the device 400.

[0064]

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

[0065]

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

[0066]

[0088] It should be noted that a video codec (for example, a codec that runs processes 200A, 200B, 300A, or 300B) can be implemented as any combination of any software or hardware modules within the device 400. For example, some or all stages of processes 200A, 200B, 300A, or 300B may be implemented as one or more software modules of the device 400, such as program instructions that can be loaded into memory 404. In another example, some or all stages of processes 200A, 200B, 300A, or 300B may be implemented as one or more hardware modules of the device 400, such as dedicated data processing circuits (e.g., FPGA, ASIC, NPU, etc.).

[0067]

[0089] In VVC, a picture is divided into one or more tile rows and one or more tile columns. A tile is a set of CTUs that cover a rectangular area of ​​the picture. CTUs within a tile are scanned according to the raster scan order within that tile. A slice consists of an integer number of complete tiles or an integer number of consecutive complete CTU rows within a tile of the picture. As a result, each vertical slice boundary is also a vertical tile boundary. The horizontal boundaries of a slice are not tile boundaries, but may consist of horizontal CTU boundaries within a tile. This occurs when a tile is divided into multiple rectangular slices, each consisting of an integer number of consecutive complete CTU rows within the tile.

[0068]

[0090] In VVC, a coded video bitstream or bytestream, which is a series of bits in network abstraction layer (NAL) unit format, forms one or more coded video sequences (CVS), and each CVS consists of one or more coded layer video sequences (CLVS). A CLVS is a series of picture units (PUs), and each PU contains exactly one coded picture.

[0069]

[0091] A PU consists of a picture header syntax structure as a payload, one coded picture containing one or more video coding layer (VCL) NAL units, and zero or one picture header (PH) NAL units containing zero or more other non-VCL NAL units. A VCL NAL unit contains a coded slice consisting of a slice header and slice data.

[0070]

[0092] In VVC, the quantization parameter (QP) can range from 0 to 63, and the signaling of the initial QP can be modified accordingly. If a non-zero value of slice_qp_delta is coded in the slice header, the initial value of SliceQpY is modified at the slice level. In particular, the value of init_qp_minus26 is modified so that it is within the range of (-26+QpBdOffsetY) to +37. If the size of the transformation block is not a power of 4, the transformation coefficients are calculated along with modifications to the QP or QP levelScale table, rather than by multiplication by 181 / 256 (or 181 / 128) to compensate for the implicit scaling by the transformation process. The process is executed. In the transformation skip block, the minimum allowed QP is set to 4 because when QP is equal to 4, the quantization step size becomes 1.

[0071]

[0093] In addition, the QP value can be changed for each CU or for each quantization group. Delta QP values ​​for the luma and chromatic components can be signaled separately.

[0072]

[0094] For each Lumacoded block, the variable qP Y_PREV First, we derive the following: - If one or more of the following conditions are true, then q PY_PREV Set this to equal to SliceQpY: - The current quantization group is the first quantization group within the slice. - The current quantization group is the first quantization group in the tile. - Otherwise, qP Y_PREV Qp is the luma quantization parameter of the last luma-encoded unit in the previous quantization group in the decoding order. Y Set it to be equal to.

[0073]

[0095] Secondly, the variable qP Y_A We derive the following: - qP if one or more of the following conditions are true. Y_A to qPY_PREV Set it equal to: - The adjacent block to the left of the current quantization group cannot be used. - The adjacent block to the left of the current quantization group and the current coded block are in different coded tree blocks (CTBs). - Otherwise, qP Y_A is set equal to the luma quantization parameter of the coding unit above the current quantization group.

[0074]

[0096] Thirdly, the variable qP Y_B is derived as follows: - If one or more of the following conditions are true, qP Y_B is set equal to qP Y_PREV : - The adjacent block above the current quantization group cannot be used. - The adjacent block above the current quantization group and the current coded block are in different coded tree blocks (CTBs). - Otherwise, qP Y_B is set equal to the luma quantization parameter of the coding unit to the left of the current quantization group.

[0075]

[0097] Fourthly, if the current quantization group is the first quantization group in the coded tree block (CTB) row within the block and the adjacent block above the current quantization group can be used, set qPY_PRED to qPY_B, otherwise qPY_PRED = (qPY_A + qPY_B + 1) >> 1

[0076]

[0098] After deriving qPY_PRED, the quantization parameter Qp’ Y of the current luma coded block can be derived using Equation 1 below: Qp’ Y=((qPY_PRED+CuQpDeltaVal+64+2*QpBdOffsetY)%(64+QpBdOffsetY)) (Equation 1) However, QpBdOffsetY is equal to 6*sps_bitdepth_minus8, and the variable CuQpDeltaVal specifies the difference between the quantization parameter of the lumacoded block and its predicted value.

[0077]

[0099] In VVC, CuQpDeltaVal is cu_qp_delta_abs*(1-2*cu_qp_delta_sign_flag) It is specified as such, where cu_qp_delta_abs and cu_qp_delta_sign_flag are syntactic elements that are signaled in the bitstream at the CU level. If cu_qp_delta_abs and cu_qp_delta_sign_flag are not present in the bitstream, CuQpDeltaVal can be inferred to be 0.

[0078]

[0100] The quantization parameter for the chromaticized block is Qp Y It may differ from that. Mac quantization parameter (Qp Cb Qp Cr Qp CbCr The offset between the chromatic quantization parameter and the chroma quantization parameter can be signaled within the bitstream. In VVC, the chromatic quantization parameter Qp' is used with equations 2-4 below. Cb and Qp' Cr , and joint Cb-Cr coding Qp' is the QP of the eye. CbCr We can derive: Qp' Cb =Clip3(-QpBdOffset c ,63,qP Cb +pps_cb_qp_offset+slice_cb_qp_offset+CuQpOffset Cb )+QpBdOffset C (Equation 2) Qp' Cr=Clip3(-QpBdOffset c ,63,qP Cr +pps_cr_qp_offset+slice_cr_qp_offset+CuQpOffset Cr )+QpBdOffset C (Equation 3) Qp' CbCr =Clip3(-QpBdOffset c ,63,qP CbCr +pps_cbcr_qp_offset+slice_cbcr_qp_offset+CuQpOffset CbCr )+QpBdOffset C (Equation 4) However, qP Cb , qP Cr , and qP CbCr Qp Y Clipped values Using the input, it can be derived from the reference table: qPi Chroma =Clip3(-QpBdOffset,63,Qp Y -QpBdOffset) (Equation 5) qP Cb =ChromaQpTable[0][qP Chroma ] (Equation 6) qP Cr =ChromaQpTable[1][qP Chroma ] (Equation 7) qP CbCr =ChromaQpTable[2][qP Chroma ] (Equation 8)

[0079]

[0101] If cu_chroma_qp_offset_flag is equal to 0, CuQpOffset Cb CuQpOffset Cr、 and CuQpOffset CbCr If it is set to 0 and cu_chroma_qp_offset_flag is equal to 1, then equations 9-11 can be used to derive it: CuQpOffset Cb=cb_qp_offset_list[cu_chroma_qp_offset_idx] (Equation 9) CuQpOffset Cr =cr_qp_offset_list[cu_chroma_qp_offset_idx] (Equation 10) CuQpOffset CbCr =joint_cbcr_qp_offset_list[cu_chroma_qp_offset_idx] (Equation 11 ) However, cu_chroma_qp_offset_flag and cu_chroma_qp_offset_idx are within the bitstream. It is a syntactic element that is signaled.

[0080]

[0102] As discussed above, cu_qp_delta_abs and cu_qp_delta_sign_flag are signaled to derive CuQpDeltaVal, which can be used to derive QP. CuQpOffset, which can be used to derive chroma QP. Cb CuQpOffset Cr , and CuQpOffset CbCr To derive this, cu_chroma_qp_offset_flag, cu_chroma_qp_offset_idx, cb_qp_offset_list[i], cr_qp_offset_list[i], and joint_cbcr_qp_offset_list[i] are signaled.

[0081]

[0103] The following is an introduction to the signaling process for the relevant syntax. First, as shown in Figure 5, which illustrates the exemplary PPS syntax for CU delta QP, cu_qp_delta_enabled_flag, cu_qp_delta_subdiv, cu_chroma_qp_offset_enabled_flag, and cu_chroma_qp_offset_subdiv can be signaled within the Picture Parameter Set (PPS).

[0082]

[0104] Subsequently, as shown in Figure 6, which illustrates an exemplary coded tree syntax for CU Delta QP, the variables IsCuQpDeltaCoded and IsCuChromaQpOffsetCoded, the quantization parameter group The location of the loop, as well as the variables qgOnY and qgOnC, can be derived at the coding tree level.

[0083]

[0105] Furthermore, as shown in Figure 7, IsCuQpDeltaCoded and IsCuChromaQpOffsetCoded, which demonstrate exemplary conversion unit-level syntax for CU Delta QP, are at the coding unit level. Provided that it has been derived, cu_qp_delta_abs / cu_qp_delta_sign_flag and cu_chroma_qp_offset_flag / cu_chroma_qp_offset_idx are signaled in the conversion unit.

[0084]

[0106] In the example in Figure 5, cu_qp_delta_subdiv specifies the maximum cbSubdiv value for the coding unit that transmits cu_qp_delta_abs and cu_qp_delta_sign_flag, and cu_chroma_qp_offset_subdiv specifies the maximum cbSubdiv value for the coding unit that transmits cu_chroma_qp_offset_flag. cbSubdiv is a variable whose value relates to the size of the coding unit. Smaller coding units have larger cbSubdiv values. By dividing a coding unit into multiple subcoding units... The value of cbSubdiv increases. The range of values ​​for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv depends on a variable called MaxMttDepthY, which is derived based on the slice level and slice type. MaxMttDepthY=slice_max_mtt_hierarchy_depth_luma (Equation 12) However, slice_max_mtt_hierarchy_depth_luma is signaled within the slice header, as shown in Figure 8, which illustrates exemplary slice header syntax.

[0085]

[0107] As explained above, in order to determine the maximum depth of the coding unit that can pass cu_qp_delta_abs / cu_qp_delta_sign_flag and cu_chroma_qp_offset_flag, two syntax elements are required. The subscripts cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are signaled within the PPS level. However, the range of values ​​for cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv depends on the variable MaxMttDepthY, which is derived based on the slice level and slice type. Therefore, the syntactic elements at the PPS level depend on the slice level syntax.

[0086]

[0108] In bitstream syntax, the PPS is at a higher level than the slice level, and the PPS syntax precedes the slice syntax. Decoders can reference the values ​​of the higher-level syntax when parsing the lower-level syntax, but they cannot reference the values ​​of the lower-level syntax when parsing the higher-level syntax. Therefore, in current VVC techniques, the reliance of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv on the slice header syntax creates a logical problem that needs to be resolved.

[0087]

[0109] To address the above issues, solutions are provided in various embodiments of this disclosure. In some embodiments, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be moved to the slice header after slice_max_mtt_hierarchy_depth_luma has been signaled. Thereafter, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are no longer PPS-level syntactic elements. An example of slice header syntax is shown in Figure 9 (e.g., element 901).

[0088]

[0110] In the example shown in Figure 9, cu_qp_delta_enabled_flag and cu_chroma_qp_offset_enabled_flag are signaled within the PPS. In some embodiments, cu_qp_delta_enabled_flag and cu_chroma_qp_offset_enabled_flag may be signaled within the slice header, as shown in Figure 10 (e.g., element 1001).

[0089]

[0111] In the example shown in Figure 10, the ranges of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be determined as follows. For example, the range of values ​​for cu_qp_delta_subdiv can be specified as follows. When slice_type is equal to I, the value of cu_qp_delta_subdiv It is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+MaxMttDepthY) (including both ends). (Hmm). If not (slice_type is not equal to I), the value of cu_qp_delta_subdiv is 0. It is within the range of ~2*(CtbLog2SizeY-MinQtLog2SizeInterY+MaxMttDepthY). If it does not exist... Therefore, we can infer that the value of cu_qp_delta_subdiv is equal to 0.

[0090]

[0112] The range of the value of cu_chroma_qp_offset_subdiv can be specified as follows: If slice_type is equal to I, the value of cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+MaxMttDepthY). Otherwise (slice_type is I) If not equal to , the value of cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+MaxMttDepthY). If not found, the value of cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0091]

[0113] In some embodiments, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are moved to the picture header, and at the same time, the syntax used to derive MaxMttDepthY is changed. The base data is also moved to the picture header, and therefore the ranges of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv do not depend on the slice level syntax.

[0092]

[0114] Since one picture may contain multiple slices having different types of inter and intra slices, in this embodiment, cu_qp_delta_subdiv is divided into two syntactic elements, namely ph_cu_qp_delta_subdiv_intra_slice and ph_cu_qp_delta_subdiv_inter_slice. cu_chroma_qp_offset_subdiv is divided into two syntactic elements, namely ph_cu_chroma_qp_offset_subdiv_intra_slice and ph_cu_chroma_qp_offset_subdiv_inter_slice. ph_cu_qp_delta_subdiv_intra_slice and ph_cu_chroma_qp_offset_subdiv_intra_slice are for intra slices within the current picture, and ph_cu_qp_delta_subdiv_inter_slice And ph_cu_chroma_qp_offset_subdiv_inter_slice is for inter-slice within the current picture. Yes, there are two syntactic elements, namely ph_max_mtt_hierarchy_depth_intra_slice_luma And ph_max_mtt_hierarchy_depth_inter_slice is signaled for MaxMttDepthY of the intraslice and interslice.

[0093]

[0115] An example of picture header syntax is shown in Table 11 of Figure 11. As shown in Table 11, ph_cu_qp_delta_subdiv_intra_slice (e.g., element 1101), ph_cu_chroma_qp_offset_subdiv_intra_slice (e.g., element 1102), ph_cu_qp_delta_subdiv_inter_slice (e.g., (e.g., element 1103), and ph_cu_chroma_qp_offset_subdiv_inter_slice (e.g., element 11 04) is shown in italics and gray.

[0094]

[0116] Regarding intra-slice, ph_cu_qp_delta_subdiv_intra_slice specifies the maximum cbSubdiv value of the coding unit within the intra-slice that transmits cu_qp_delta_abs and cu_qp_delta_sign_flag. The value of ph_cu_qp_delta_subdiv_intra_slice is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+ph_max_mtt_hierarchy_depth_intra_slice_luma). If it does not exist, the value of ph_cu_qp_delta_subdiv_intra_slice can be inferred to be equal to 0. can.

[0095]

[0117] ph_cu_chroma_qp_offset_subdiv_intra_slice sets cu_chroma_qp_offset_flag Specifies the maximum cbSubdiv value for the coding unit within the transmitted intra-slice. The value of ph_cu_chroma_qp_offset_subdiv_intra_slice is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+ph_max_mtt_hierarchy_depth_intra_slice_luma). If it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_intra_slice can be inferred to be equal to 0.

[0096]

[0118] In the disclosed embodiment, ph_max_mtt_hierarchy_depth_intra_slice_luma is The Kucha header signals and specifies the maximum hierarchy depth of the coding unit resulting from the multi-type tree split of the leaves of a quad tree in a slice (i.e., an intra-prediction slice) that has sh_slice_type equal to "I". CtbLog2SizeY and MinQtLog2SizeIntraY are given by the following equation 1 Derived using 3-15, in these equations CtbLog2SizY represents the size of a Luma-encoded tree block per coded tree unit within a slice with slice_type equal to "I" (i.e., an intra-predictive slice), and MinQtLog2SizeIntraY represents the minimum size within a Luma-sample of a Luma-leaf block resulting from a quadtree partition per coded tree unit within a slice with slice_type equal to "I". CtbLog2SizeY=sps_log2_ctu_size_minus5+5 (Equation 13) MinQtLog2SizeIntraY=sps_log2_diff_min_qt_min_cb_intra_slice_luma+MinCbLog2SizeY (Equation 14) MinCbLog2SizeY=sps_log2_min_luma_coding_block_size_minus2+2 (Equation 15)

[0097]

[0119] sps_log2_ctu_size_minus5, sps_log2_diff_min_qt_min_cb_intra_slice_luma, and sps_log2_min_luma_coding_block_size_minus2 are signaled within SPS. It is a sentence element.

[0098]

[0120] The variable CuQpDeltaSubdiv transmits cu_qp_delta_abs and cu_qp_delta_sign_flag. The variable CuChromaQpOffsetSubdiv is derived as the maximum cbSubdiv value of the coding unit that transmits cu_chroma_qp_offset_flag. These two variables are derived as equations 16 and 17, respectively. CuQpDeltaSubdiv=ph_cu_qp_delta_subdiv_intra_slice (Equation 16) CuChromaQpOffsetSubdiv=ph_cu_chroma_qp_offset_subdiv_intra_slice (Equation 17)

[0099]

[0121] Regarding interslice, ph_cu_qp_delta_subdiv_inter_slice is interslice Specifies the maximum cbSubdiv value for the coding unit that transmits cu_qp_delta_abs and cu_qp_delta_sign_flag within the `ph_cu_qp_delta_subdiv_inter_slice`. The value of ph_cu_qp_delta_subdiv_inter_slice can be within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+ph_max_mtt_hierarchy_depth_inter_slice). If it does not exist, the value of ph_cu_qp_delta_subdiv_inter_slice can be inferred to be equal to 0. ph_cu_chroma_qp_offset_subdiv_inter_slice transmits cu_chroma_qp_offset_flag. Specifies the maximum cbSubdiv value for the coding unit within the interslice. The value of ph_cu_chroma_qp_offset_subdiv_inter_slice is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+ph_max_mtt_hierarchy_depth_inter_slice). If it does not exist, the value of ph_cu_chroma_qp_offset_subdiv_inter_slice can be inferred to be equal to 0.

[0100]

[0122] ph_max_mtt_hierarchy_depth_inter_slice can be signaled within the picture header and specifies the maximum hierarchy depth of the coding units resulting from the multi-type tree splitting of quadtree leaves in slices with sh_slice_type not equal to "I" (i.e., inter-predicted slices with slice_type equal to "P" or "B"). CtbLog2SizY and MinQtLog2SizeInterY are derived using the following equations 18-20, where CtbLog2SizY This is a coded tree block on a per-coded tree basis within a slice that has a slice_type not equal to "I" (i.e., an interprediction slice with a slice_type equal to "P" or "B"). Representing the size of a block, MinQtLog2SizeInterY represents the minimum size within a sample of a lumma block resulting from a quadtree partition of a coding tree unit within a slice with slice_type that is not equal to "I". CtbLog2SizeY=sps_log2_ctu_size_minus5+5 (Equation 18) MinQtLog2SizeInterY=sps_log2_diff_min_qt_min_cb_inter_slice_luma+MinCbLog2SizeY (Equation 19) MinCbLog2SizeY=sps_log2_min_luma_coding_block_size_minus2+2 (Equation 20)

[0101]

[0123] sps_log2_ctu_size_minus5, sps_log2_diff_min_qt_min_cb_inter_slice_luma, and sps_log2_min_luma_coding_block_size_minus2 are syntactic elements that are signaled within SPS.

[0102]

[0124] The variable CuQpDeltaSubdiv transmits cu_qp_delta_abs and cu_qp_delta_sign_flag. The variable CuChromaQpOffsetSubdi is derived as the maximum cbSubdiv value of the coding unit that transmits cu_chroma_qp_offset_flag. The two variables are derived as Equations 21 and 22, respectively. CuQpDeltaSubdiv=ph_cu_qp_delta_subdiv_inter_slice (Equation 21) CuChromaQpOffsetSubdiv=ph_cu_chroma_qp_offset_subdiv_inter_slice (Equation 22)

[0103]

[0125] In some embodiments, both cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv may be signaled at the PPS level and within the slice header. For example, as shown in Figure 12 (e.g., elements 1201 and 1202), pps_cu_qp_delta_subdiv and pps_cu_chroma_qp_offset_subdiv are signaled within the PPS syntax. Figure 13 (e.g., element 1201 and 1202) As shown in 1301), slice_cu_qp_delta_subdiv and slice_cu_chroma_qp_offset_subdiv are also signaled within the slice header.

[0104]

[0126] In some embodiments, the ranges of pps_cu_qp_delta_subdiv and pps_cu_chroma_qp_offset_subdiv depend on the syntax of the Sequence Parameter Set (SPS), as shown in the following example. In this example, the range of values ​​for pps_cu_qp_delta_subdiv is specified as follows: The value of pps_cu_qp_delta_subdiv is in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+SpsMaxMttDepthY). It is present within the range. If it does not exist, the value of pps_cu_qp_delta_subdiv can be inferred to be equal to 0. The range of values ​​for pps_cu_chroma_qp_offset_subdiv is specified as follows: The value of pps_cu_chroma_qp_offset_subdiv is 0~2*(CtbLog2SizeY-MinQtLog2SizeY+SpsMaxMttDepthY) It can be within the range. If it does not exist, the value of pps_cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0105]

[0127] If ctbLog2SizeY is defined, MinQtLog2SizeY and SpsMaxMttDepthY are as follows: It can be derived as follows.

[0106]

[0128] In one way, MinQtLog2SizeY is: min(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) or max(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) It can be derived as follows.

[0107]

[0129] It should be understood that MinQtLog2SizeIntraY and MinQtLog2SizeIntraY can be derived using various techniques as defined in VVC Draft 6.

[0108]

[0130] Alternatively, the value of MinQtLog2SizeY can be derived based on the following equation 23: MinQtLog2SizeY=sps_log2_diff_min_qt_min_cb_luma+MinCbLog2SizeY (Equation 23)

[0109]

[0131] However, sps_log2_diff_min_qt_min_cb_luma is signaled within SPS as shown in Figure 14 (e.g., element 1401). It will be understood that MinCbLog2SizeY can be derived using various techniques as defined in VVC Draft 6.

[0110]

[0132] Regarding SpsMaxMttDepth, one way to derive SpsMaxMttDepthY is as follows It can be released: min(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) or max(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) However, sps_max_mtt_hierarchy_depth_intra_slice_luma and sps_max_mtt_hierarchy_depth_inter_slice can be signaled within SPS.

[0111]

[0133] Alternatively, the value of SpsMaxMttDepthY can be derived as follows: ru: SpsMaxMttDepthY=sps_max_mtt_depth_luma (Equation 24) However, sps_max_mtt_depth_luma can be signaled within SPS, as shown in Figure 14 (for example, element 1402).

[0112]

[0134] In the example above, the PPS syntax elements pps_cu_qp_delta_subdiv and pps_cu_chroma_qp _offset_subdiv depends on the SPS syntax. Such parsing dependencies between PPS and SPS can be undesirable. To address this dependency issue, in some embodiments, the range of values ​​for pps_cu_qp_delta_subdiv can be specified as follows:

[0113]

[0135] The value of pps_cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+ppsMaxMttDepthY). If it does not exist, the value of pps_cu_qp_delta_subdiv is equal to 0. We can infer that.

[0114]

[0136] The range of the value of pps_cu_chroma_qp_offset_subdiv can be specified as follows: The value of pps_cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+ppsMaxMttDepthY). If it does not exist, the value of pps_cu_chroma_qp_offset_subdiv will be used. It can be inferred that this is equal to 0.

[0115]

[0137] CtbLog2SizeY, MinQtLog2SizeY, and ppsMaxMttDepthY are derived as follows: reru: CtbLog2SizeY=pps_log2_ctb_size (Equation 25) MinQtLog2SizeY=pps_log2_min_qt (Equation 26) ppsMaxMttDepthY=pps_max_mtt_depth_luma (Equation 27)

[0116]

[0138] pps_log2_ctb_size, pps_log2_min_qt, and pps_max_mtt_depth_luma can be signaled within PPS as shown in Figure 15 (e.g., element 1501).

[0117]

[0139] In the example above, the ranges of slice_cu_qp_delta_subdiv and slice_cu_chroma_qp_offset_subdiv depend on the slice header syntax. For example, the range of values ​​for slice_cu_qp_delta_subdiv can be specified as follows: If slice_type is equal to I, the value of slice_cu_qp_delta_subdiv is in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+SliceMaxMttDepthY). It is within the bounds. If not (slice_type is not equal to I), the value of slice_cu_qp_delta_subdiv is within the range of 0~2*(CtbLog2SizeY-MinQtLog2SizeInterY+SliceMaxMttDepthY) If it does not exist, the value of slice_cu_qp_delta_subdiv can be inferred to be 0 or equal to pps_cu_qp_delta_subdiv.

[0118]

[0140] The range of the value of slice_cu_chroma_qp_offset_subdiv can be specified as follows: If slice_type is equal to I, the value of slice_cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+SliceMaxMttDepthY). Otherwise If (slice_type is not equal to I), the value of slice_cu_chroma_qp_offset_subdiv is within the range of 0 to 2 * (CtbLog2SizeY - MinQtLog2SizeInterY + SliceMaxMttDepthY). If it does not exist... In conclusion, the value of slice_cu_chroma_qp_offset_subdiv can be inferred to be 0 or equal to pps_cu_chroma_qp_offset_subdiv.

[0119]

[0141] When CtbLog2SizeY, MinQtLog2SizeIntraY, and MinQtLog2SizeInterY are defined, SliceMaxMttDepthY is SliceMaxMttDepthY=slice_max_mtt_hierarchy_depth_luma (Equation 28) It can be derived as follows.

[0120]

[0142] `slice_max_mtt_hierarchy_depth_luma` can be signaled within the slice header.

[0121]

[0143] In the example above, cu_qp_delta_subdiv can be inferred to be slice_cu_qp_delta_subdiv. Alternatively, cu_qp_delta_subdiv can be inferred to be pps_cu_qp_delta_subdiv first, and if slice_cu_qp_delta_subdiv exists, then slice_cu_qp_delta_subdiv is By performing a dyscalar operation, we can infer that cu_qp_delta_subdiv is slice_cu_qp_delta_subdiv. The value of cu_qp_delta_subdiv is Qp Y It can be used to derive the following.

[0122]

[0144] Furthermore, cu_chroma_qp_offset_subdiv can be inferred to be slice_cu_chroma_qp_offset_subdiv. Alternatively, cu_chroma_qp_offset_subdiv can be initially inferred to be pps_cu_chroma_qp_offset_subdiv, and if slice_cu_chroma_qp_offset_subdiv exists, slice_cu_chroma_qp_offset_subdiv overrides it, and cu_chroma_qp_offset_subdiv can be inferred to be slice_cu_chroma_qp_offset_subdiv. The value of cu_chroma_qp_offset_subdiv is Qp Cb Qp Cr QP CbCr It can be used to derive the following.

[0123]

[0145] In some embodiments, both cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be signaled at the SPS level and within the slice header. As shown in Figure 16 (e.g., element 1601), sps_cu_qp_delta_subdiv and sps_cu_chroma_qp_offset_subdiv can be signaled within the SPS, and as shown in Figure 17 (e.g., element 1701), slice_cu_qp_delta_subdiv and slice_cu_chroma_qp_offset_subdiv can be signaled within the slice header.

[0124]

[0146] In some embodiments, the ranges of sps_cu_qp_delta_subdiv and sps_cu_chroma_qp_offset_subdiv depend on the SPS syntax. For example, the range of values ​​for sps_cu_qp_delta_subdiv can be specified as follows: The value of sps_cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+SpsMaxMttDepthY). If it does not exist, the value of sps_cu_qp_delta_subdiv can be inferred to be equal to 0. Value of sps_cu_chroma_qp_offset_subdiv The range is specified as follows: The value of sps_cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+SpsMaxMttDepthY). If it does not exist, the value of sps_cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0125]

[0147] If ctbLog2SizeY is defined, MinQtLog2SizeY and SpsMaxMttDepthY are as follows It can be derived as follows.

[0126]

[0148] In one way, MinQtLog2SizeY is min(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) or max(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) It can be derived as follows.

[0127]

[0149] However, MinQtLog2SizeIntraY and MinQtLog2SizeIntraY can be derived using various techniques as defined in VVC Draft 6.

[0128]

[0150] Alternatively, the value of MinQtLog2SizeY can be derived using the following equation 29. MinQtLog2SizeY=sps_log2_diff_min_qt_min_cb_luma+MinCbLog2SizeY (Equation 29)

[0129]

[0151] sps_log2_diff_min_qt_min_cb_luma can be signaled within SPS as shown in Figure 18 (e.g., element 1801). It will be understood that MinCbLog2SizeY can be derived using various techniques as defined in VVC Draft 6.

[0130]

[0152] Regarding SpsMaxMttDepthY, in one way SpsMaxMttDepthY is min(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) or max(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) It can be derived as follows.

[0131]

[0153] sps_max_mtt_hierarchy_depth_intra_slice_luma and sps_max_mtt_hierarchy_depth_inter_slice can be signaled within SPS.

[0132]

[0154] Alternatively, SpsMaxMttDepthY is SpsMaxMttDepthY=sps_max_mtt_depth_luma (Equation 30) It can be derived as follows.

[0133]

[0155] sps_max_mtt_depth_luma can be signaled within SPS as shown in Figure 18 (e.g., element 1802).

[0134]

[0156] Furthermore, in the above example, the ranges of slice_cu_qp_delta_subdiv and slice_cu_chroma_qp_offset_subdiv depend on the slice header syntax. For example, the range of values ​​for slice_cu_qp_delta_subdiv can be specified as follows: If slice_type is equal to I, the value of slice_cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+SliceMaxMttDepthY). It is located there. If not (slice_type is not equal to I), slice_cu_qp_delta_subdiv The value of is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+SliceMaxMttDepthY). If it does not exist, the value of slice_cu_qp_delta_subdiv can be inferred to be 0 or equal to sps_cu_qp_delta_subdiv.

[0135]

[0157] The value of slice_cu_chroma_qp_offset_subdiv can be specified as follows: If slice_type is equal to I, the value of slice_cu_chroma_qp_offset_subdiv is in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+SliceMaxMttDepthY). Otherwise (slice_type is not equal to I), the value of slice_cu_chroma_qp_offset_subdiv is in the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+SliceMaxMttDepthY). If it does not exist, the value of slice_cu_chroma_qp_offset_subdiv can be inferred to be 0 or equal to sps_cu_chroma_qp_offset_subdiv.

[0136]

[0158] When CtbLog2SizeY, MinQtLog2SizeIntraY, and MinQtLog2SizeInterY are defined, SliceMaxMttDepthY is SliceMaxMttDepthY=slice_max_mtt_hierarchy_depth_luma (Equation 31) It can be derived as follows.

[0137]

[0159] `slice_max_mtt_hierarchy_depth_luma` can be signaled within the slice header.

[0138]

[0160] In the example above, cu_qp_delta_subdiv can be inferred to be slice_cu_qp_delta_subdiv. Alternatively, cu_qp_delta_subdiv can be initially inferred to be sps_cu_qp_delta_subdiv, and if slice_cu_qp_delta_subdiv exists, slice_cu_qp_delta_subdiv will override it, and cu_qp_delta_subdiv can be inferred to be slice_cu_qp_delta_subdiv. Cu_qp_delta_subdiv is Qp Y It can be used to derive the following.

[0139]

[0161] Furthermore, in the above example, cu_chroma_qp_offset_subdiv can be inferred to be slice_cu_chroma_qp_offset_subdiv. Alternatively, cu_chroma_qp_offset_subdiv can be initially inferred to be sps_cu_chroma_qp_offset_subdiv, and if slice_cu_chroma_qp_offset_subdiv exists, slice_cu_chroma_qp_offset_subdiv will override it, and cu_chroma_qp_offset_subdiv can be inferred to be slice_cu_chroma_qp_offset_subdiv. Cu_chrom a_qp_offset_subdiv is Qp Cb Qp Cr QP CbCr It can be used to derive the following.

[0140]

[0162] In some embodiments, the syntax of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv may be signaled at the PPS level. However, the range restrictions of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be modified so that they do not depend on the slice syntax.

[0141]

[0163] As an example, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be signaled within PPS as shown in Figure 5. The range of values ​​for cu_qp_delta_subdiv can be specified as follows: The range of cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_qp_delta_subdiv can be inferred to be equal to 0. The range of values ​​for cu_chroma_qp_offset_subdiv can be specified as follows: The value of cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0142]

[0164] If ctbLog2SizeY is defined, MinQtLog2SizeY and MaxMttDepthY can be inferred at the SPS level. For example, MaxMttDepthY is min(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) or max(sps_max_mtt_hierarchy_depth_intra_slice_luma, sps_max_mtt_hierarchy_depth_inter_slice) It can be derived as follows.

[0143]

[0165] sps_max_mtt_hierarchy_depth_intra_slice_luma and sps_max_mtt_hierarchy_depth_inter_slice can be signaled within SPS.

[0144]

[0166] Alternatively, MaxMttDepthY is MaxMttDepthY=sps_max_mtt_depth_luma It can be derived as follows.

[0145]

[0167] sps_max_mtt_depth_luma can be signaled within SPS as shown in Figure 19 (e.g., element 1901).

[0146]

[0168] In one way, MinQtLog2SizeY min(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) or max(MinQtLog2SizeIntraY, MinQtLog2SizeInterY) It can be derived as follows.

[0147]

[0169] It should be understood that MinQtLog2SizeIntraY and MinQtLog2SizeIntraY can be derived using various techniques as defined in VVC Draft 6.

[0148]

[0170] Alternatively, the value of MinQtLog2SizeY can be derived based on the following equation 32: MinQtLog2SizeY=sps_log2_diff_min_qt_min_cb_lima+MinCbLog2SizeY (Equation 32)

[0149]

[0171] sps_log2_diff_min_qt_min_cb_luma is signaled within SPS as shown in Figure 13 (e.g., element 1301). MinCbLog2SizeY is defined in VVC Draft 6. It will be understood that it can be derived using various techniques such as those mentioned above.

[0150]

[0172] Based on the example above, the ranges of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are not overridden at the slice header level.

[0151]

[0173] In some embodiments, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv may be signaled at the PPS level. However, the range restrictions of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be fixed so that they do not depend on the slice syntax.

[0152]

[0174] For example, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv can be signaled within PPS as shown in Figure 5. The range of values ​​for cu_qp_delta_subdiv can be specified as follows: The value of cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_qp_delta_subdiv can be inferred to be equal to 0. The range of values ​​for cu_chroma_qp_offset_subdiv can be specified as follows: The value of cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0153]

[0175] However, CtbLog2SizeY, MinQtLog2SizeY, and MaxMttDepthY can be derived in the following way: CtbLog2SizeY / MinQtLog2SizeY / MaxMttDepthY can be specified by a profile, or CtbLog2SizeY / MinQtLog2SizeY / MaxMttDepthY can be fixed values.

[0154]

[0176] Based on the example above, the ranges of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are not overridden at the slice header level.

[0155]

[0177] In some embodiments, cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv may be signaled within the PPS as shown in Figure 5. The range of values ​​for cu_qp_delta_subdiv can be specified as follows: The value of cu_qp_delta_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_qp_delta_subdiv can be inferred to be equal to 0. The range of values ​​for cu_chroma_qp_offset_subdiv is specified as follows: The value of cu_chroma_qp_offset_subdiv is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeY+MaxMttDepthY). If it does not exist, the value of cu_chroma_qp_offset_subdiv can be inferred to be equal to 0.

[0156]

[0178] CtbLog2SizeY, MinQtLog2SizeY, and MaxMttDepthY can be inferred at the PPS level. For example, CtbLog2SizeY=pps_log2_ctb_size (Equation 33) MinQtLog2SizeY=pps_log2_min_qt (Equation 34) MaxMttDepthY=pps_max_mtt_depth_luma (Equation 35)

[0157]

[0179] pps_log2_ctb_size, pps_log2_min_qt, and pps_max_mtt_depth_luma are signaled within PPS as shown in Figure 20 (e.g., element 2001).

[0158]

[0180] Based on the example above, the ranges of cu_qp_delta_subdiv and cu_chroma_qp_offset_subdiv are not overridden at the slice header level.

[0159]

[0181] Figure 21 is a flowchart of a computer-implemented method 2100 for processing video content, consistent with an embodiment of the present disclosure.

[0160]

[0182] In step 2102, a depth parameter related to the depth of the coded block can be received. The depth parameter may be a variable "MaxMttDepthY" derived from, for example, the maximum depth of the multitype tree hierarchy of the luma block (e.g., "slice_max_mtt_hierarchy_depth_luma"). In some embodiments, "slice_max_mtt_hierarchy_depth_luma" may be signaled within the slice header associated with the coded block.

[0161]

[0183] A coded block can be associated with a slice. A slice can be associated with intra-prediction or inter-prediction. Depending on whether the slice is associated with intra-prediction, a delta QP value or chroma QP offset value can be determined for slices associated with intra-prediction. Otherwise, depending on whether the slice is associated with inter-prediction, a delta QP value or chroma QP offset value can be determined for slices associated with inter-prediction. For example, if "slice_type" is equal to "I" (the slice is associated with intra-prediction) If it indicates that the slice is related to interpretation, the value of "cu_qp_delta_subdiv" is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+MaxMttDepthY). Otherwise, if "slice_type" is not equal to "I" (indicating that the slice is related to interpretation), the value of "cu_qp_delta_subdiv" is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+MaxMttDepthY). Furthermore For example, if "slice_type" is equal to "I", then "cu_chroma_qp_offset_subdiv" The value is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeIntraY+MaxMttDepthY). If "slice_type" is not equal to "I", then the value of "cu_chroma_qp_offset_subdiv" is not used. It is within the range of 0 to 2*(CtbLog2SizeY-MinQtLog2SizeInterY+MaxMttDepthY).

[0162]

[0184] In some embodiments, depth parameters may be signaled within the picture header. It will be understood that a picture may contain multiple slices. For slices related to intra-prediction, the corresponding delta-QP value or chroma-QP offset value can be determined for the slice related to intra-prediction. For slices related to inter-prediction, the corresponding delta-QP value or chroma-QP offset value can be determined for the slice related to inter-prediction. For example, as discussed with respect to Table 11 in Figure 11, ph_cu_qp_delta_subdiv_intra_slice and ph_cu_chroma_qp_offset_subdiv_intra_slice are signaled within the picture header to derive the delta-QP value and chroma-QP offset value for slices related to intra-prediction. For slices related to inter-prediction, ph_cu_qp_delta_subdiv_inter_slice and ph_cu_chroma_qp_offset_subdiv_inter_slice are signaled within the picture header to derive the delta-QP value and chroma-QP offset value for slices related to inter-prediction.

[0163]

[0185] In step 2104, at least one of the delta quantization parameter (QP) value or chroma QP offset value can be determined based on the depth of the coded block. As discussed above, the delta QP value can be determined based on "cu_qp_delta_subdiv", and the chroma QP offset value can be determined based on "cu_chroma_qp_offset_subdiv", and "cu_qp_delta_subdiv" and "cu_chroma_qp_offset_subdiv" can be determined based on the variable "MaxMttDepthY".

[0164]

[0186] In step 2106, the chroma QP value can be derived based on the determined delta QP value, and the chroma QP value can be derived based on the determined chroma QP offset value.

[0165]

[0187] In step 2108, the coded block can be processed based on the derived luma QP value and the derived chroma QP value.

[0166]

[0188] In some embodiments, a non-temporary computer-readable storage medium containing instructions is also provided. The instructions may be executed by an apparatus for performing the above method (such as the disclosed encoder and decoder). Common non-temporary media include, for example, floppy disks, flexible disks, hard disks, solid-state drives, magnetic tapes or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media having a pattern of holes, RAM, PROMs and EPROMs, flash EPROMs or any other flash memory, NVRAM, caches, registers, any other memory chips or cartridges and networked versions thereof. The apparatus may include one or more processors (CPUs), input / output interfaces, network interfaces and / or memory.

[0167]

[0189] Embodiments may be further described using the following clauses: 1. A method implemented by a computer, Receiving a bitstream containing coded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determine at least one of the delta QP value or chroma QP offset value according to one or more second parameters. Methods that include... 2. Determining the first parameter of the coding block is: Determining whether a coded block is related to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to an intra-predictive slice, determine that the first parameter is a parameter related to the intra-predictive slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. The method described in Clause 1, including the method described in Clause 1. 3. The method according to Clause 1, wherein the first parameter is signaled within the slice header associated with the coded block. 4. The method according to Clause 1, wherein the first parameter is signaled within the picture header associated with the coded block. 5. Determine the Luma QP value based on the Delta QP value. Determining the chroma QP value based on the chroma QP offset value, and Processing coded blocks based on Luma QP values ​​and Chroma QP values. The method described in Clause 1, further including the following: 6. A system for processing video content, A memory that stores one set of instructions, It includes at least one processor, and at least one processor is Receiving a bitstream containing coded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determine at least one of the delta QP value or chroma QP offset value according to one or more second parameters. A system configured to execute a set of instructions in order to perform a certain action. 7. At least one processor, Determining whether a coded block is related to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to an intra-predictive slice, determine that the first parameter is a parameter related to the intra-predictive slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. The system described in Clause 6, configured to execute a set of instructions in order to cause the system to perform further actions. 8. The system described in Clause 6, in which the first parameter is signaled within the slice header associated with the coded block. 9. The system described in Clause 6, in which the first parameter is signaled within the picture header associated with the coded block. 10. At least one processor, Determining the Luma QP value based on the Delta QP value. Determining the chroma QP value based on the chroma QP offset value, and Processing coded blocks based on Luma QP values ​​and Chroma QP values. The system described in Clause 6, configured to execute a set of instructions in order to cause the system to perform further actions. 11. A non-temporary computer-readable medium that stores instructions executable by at least one processor of a computer system, wherein the instructions are executed by Receiving a bitstream containing coded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determine at least one of the delta QP value or chroma QP offset value according to one or more second parameters. A non-temporary, computer-readable medium that causes a computer system to perform a method including [a specific action]. 12. The method is, Determining whether a coded block is related to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to an intra-predictive slice, determine that the first parameter is a parameter related to the intra-predictive slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. Non-temporary computer-readable media as described in Clause 11, further including the above. 13. A non-temporary computer-readable medium as described in Clause 11, in which the first parameter is signaled within a slice header associated with the coded block. 14. A non-temporary computer-readable medium as described in Clause 11, in which the first parameter is signaled within a picture header associated with the coded block. 15. The method is Determining the Luma QP value based on the Delta QP value. Determining the chroma QP value based on the chroma QP offset value, and Processing coded blocks based on Luma QP values ​​and Chroma QP values. Non-temporary computer-readable media as described in Clause 11, further including the above.

[0168]

[0190] It should be noted that relational terms such as “first” and “second” in this specification are used solely to distinguish one entity or operation from another, and do not require or imply any actual relationship or order between those entities or operations. Furthermore, “include,” “have,” “contain,” and “incorporate,” as well as other similar forms of terms, are intended to be equivalent in meaning and are intended to be non-restrictive in that the items following any one of these terms are not intended to be an exhaustive list of such items, nor are they intended to be limited to only the items listed.

[0169]

[0191] When used herein, unless otherwise specified, the word “or” encompasses all possible combinations, except in impractical cases. For example, if it is stated that a database may contain A or B, then unless otherwise specified or impractical, that 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, that database may contain A or B or C, or A and B, or A and C, or B and C, or A, B, and C.

[0170]

[0192] It will be understood that the embodiments described above can be implemented by hardware, software (program code), or a combination of hardware and software. When implemented by software, the software can be stored in the computer-readable medium described above. When executed by a processor, the software can perform the methods disclosed. The computing units and other functional units described in this disclosure can be implemented by hardware, software, or a combination of hardware and software. It will also be understood by those skilled in the art that multiple of the above modules / units can be combined into a single module / unit, and each of the above modules / units can be further divided into multiple submodules / subunits.

[0171]

[0193] This specification has described embodiments with respect to numerous specific details that may vary depending on the implementation. Certain adaptations and modifications may be made to the embodiments described. Other embodiments may become apparent to those skilled in the art by examining this specification and practicing the invention disclosed herein. This specification and examples are provided for illustrative purposes only, and the true scope and spirit of this disclosure are intended to be shown by the appended claims. The order of steps shown in the figures is for illustrative purposes only and is not intended to limit the order of steps to any particular set. Therefore, those skilled in the art will understand that these steps can be performed in different orders while implementing the same method.

[0172]

[0194] Exemplary embodiments have been disclosed in the drawings and this specification. However, many variations and modifications can be made to those embodiments. Accordingly, although specific terms have been used, they are used only in a general and descriptive sense, not for limiting purposes.

Claims

1. A method performed by a computer, Receiving a bitstream containing encoded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determining at least one of the delta QP value or the chroma QP offset value according to the one or more second parameters. Methods that include...

2. Determining the first parameter of the coding block is: Determining whether the coded block relates to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to the intra-prediction slice, the first parameter is determined to be a parameter related to the intra-prediction slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. The method according to claim 1, including the method described in claim 1.

3. The method according to claim 1, wherein the first parameter is signaled in at least one slice header or picture header associated with the coded block.

4. The coding block relates to an intra-predictive slice, and the method is The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the intra-prediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multi-type tree partition of the quadtree leaves in the intra-prediction slice are determined. The method according to claim 3, further comprising:

5. The coded block relates to an interprediction slice, and the method is The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the interprediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multitype tree partition of the quadtree leaves in the interprediction slice are determined. The method according to claim 3, further comprising:

6. The Luma QP value is determined based on the aforementioned Delta QP value. Determining the chroma QP value based on the aforementioned chroma QP offset value, and Processing the coded block based on the Luma QP value and the Chroma QP value. The method according to claim 1, further comprising:

7. A system for processing video content, A memory that stores one set of instructions, It includes at least one processor, and the at least one processor is Receiving a bitstream containing encoded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determining at least one of the delta QP value or the chroma QP offset value according to the one or more second parameters. A system configured to execute the set of instructions so that the system performs the aforementioned action.

8. When determining the first parameter of the coded block, the at least one processor, Determining whether the coded block relates to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to the intra-prediction slice, the first parameter is determined to be a parameter related to the intra-prediction slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. The system according to claim 7, configured to execute the set of instructions so that the system further performs the above.

9. The system according to claim 7, wherein the first parameter is signaled in at least one slice header or picture header associated with the coded block.

10. The coded block relates to an intra-predictive slice, and the at least one processor, The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the intra-prediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multi-type tree partition of the quadtree leaves in the intra-prediction slice are determined. The system according to claim 9, configured to execute the set of instructions so that the system further performs the above.

11. The coded block relates to an interprediction slice, and the at least one processor, The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the interprediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multitype tree partition of the quadtree leaves in the interprediction slice are determined. The system according to claim 9, configured to execute the set of instructions so that the system further performs the above.

12. The aforementioned at least one processor, The Luma QP value is determined based on the aforementioned Delta QP value. Determining the chroma QP value based on the aforementioned chroma QP offset value, and Processing the coded block based on the Luma QP value and the Chroma QP value. The system according to claim 7, configured to execute the set of instructions so that the system further performs the above.

13. A non-temporary computer-readable medium for storing instructions that can be executed by at least one processor of a computer system, wherein the execution of the instructions is Receiving a bitstream containing encoded video data, To determine the first parameter of the coded block, Determining one or more second parameters related to the delta quantization parameter (QP) value or chroma QP offset value according to the first parameter, and Determining at least one of the delta QP value or the chroma QP offset value according to the one or more second parameters. A non-temporary computer-readable medium that causes the computer system to perform a method including the above.

14. Determining the first parameter of the coding block is: Determining whether the coded block relates to an intra-predictive slice or an inter-predictive slice, and Depending on whether the coded block is related to the intra-prediction slice, the first parameter is determined to be a parameter related to the intra-prediction slice, or Depending on whether the coded block is related to the interprediction slice, the first parameter is determined to be a parameter related to the interprediction slice. A non-temporary computer-readable medium according to claim 13, including the following:

15. The non-temporary computer-readable medium according to claim 13, wherein the first parameter is signaled in at least one slice header or picture header associated with the coded block.

16. The coding block relates to an intra-predictive slice, and the method is The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the intra-prediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multi-type tree partition of the quadtree leaves in the intra-prediction slice are determined. A non-temporary computer-readable medium according to claim 15, further comprising:

17. The coded block relates to an interprediction slice, and the method is The maximum value of the first parameter corresponding to the size of the Luma-encoded tree block of the coding tree unit associated with the interprediction slice, the minimum size of the Luma sample in the Luma-leaf block resulting from the quadtree partition of the coding tree unit, and the maximum hierarchical depth of the coding unit resulting from the multitype tree partition of the quadtree leaves in the interprediction slice are determined. A non-temporary computer-readable medium according to claim 15, further comprising:

18. The method described above is The Luma QP value is determined based on the aforementioned Delta QP value. Determining the chroma QP value based on the aforementioned chroma QP offset value, and Processing the coded block based on the Luma QP value and the Chroma QP value. A non-temporary computer-readable medium according to claim 13, further comprising:

Images