Tiles and slices in video processing

Abstract

This disclosure provides a computer implementation method for encoding or decoding video. [Solution] The method includes encoding or decoding a corresponding first PPS flag in a plurality of picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), indicating whether the picture is partitionable into a plurality of tiles or slices. In the first PPS, a corresponding first PPS flag having a first value indicates that the first picture in the CLVS is not partitionable, and in the second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture in the CLVS is partitionable.

Description

Technical Field

[0001] Cross - Reference to Related Applications

[0001] This disclosure claims the benefit of priority to U.S. Provisional Application No. 63 / 028,111, filed on May 21, 2020, which is incorporated herein by reference in its entirety.

[0002] Technical Field

[0002] This disclosure generally relates to video data processing, and more particularly to partitioning pictures.

Background Art

[0003] Background

[0003] Video is a set of static pictures (or "frames") that capture visual information. To reduce memory storage 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, the Versatile Video Coding (VVC / H.266) standard, and the AVS standard, which specify particular video coding formats, have been developed by standardization organizations. As more advanced video coding techniques are adopted in video standards, the coding efficiency of new video coding standards becomes higher.

Summary of the Invention

Means for Solving the Problems

[0004] Summary of the Disclosure

[0004] Embodiments of the present disclosure provide a method for encoding or decoding video. The method includes encoding or decoding corresponding first PPS flags in a plurality of picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), indicating whether the picture is partitionable into a plurality of tiles or slices. In the first PPS, a corresponding first PPS flag having a first value indicates that the first picture in the CLVS is not partitionable, and in the second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture in the CLVS is partitionable.

[0005]

[0005] In some embodiments, a method for encoding or decoding an image includes determining whether a picture can be partitioned into multiple tiles or slices, encoding or decoding a first flag in the picture parameter set (PPS) associated with the slice mode applied to the picture referencing the PPS, when a raster scan slice mode is applied to partition the picture, encoding or decoding a first flag having a first value, or when a rectangular slice mode is applied to partition the picture, encoding or decoding a first flag having a second value different from the first value. Includes.

[0006]

[0006] In some embodiments, a method for decoding video includes encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture in a coded layer video sequence (CLVS) that indicates whether the associated picture is partitionable into multiple tiles or slices, wherein the first PPS flag equal to a first value indicates that the associated picture is not partitionable, or the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable; skipping encoding or decoding a second PPS flag in the PPS that indicates whether each sub-picture of the associated picture contains a single rectangular slice when the first PPS flag is equal to the first value; and determining the value of the second PPS flag equal to a third value, wherein the second PPS flag equal to the third value indicates that each sub-picture of the associated picture contains a single rectangular slice.

[0007]

[0007] Embodiments of the present disclosure provide a device including a memory configured to store instructions and one or more processors, the one or more processors configured to execute instructions to cause the device to perform any of the above methods.

[0008]

[0008] Embodiments of the present disclosure provide a non-temporary computer-readable storage medium. The non-temporary computer-readable storage medium stores a set of instructions, the set of instructions is executable by one or more processors of a device to cause the device to perform an operation of any of the above methods.

[0009] Brief explanation of the drawing

[0009] 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]

[0010] [Figure 1]

[0010] This is a schematic diagram showing an example of the structure of a video sequence that matches some embodiments of the present disclosure. [Figure 2A]

[0011] This is a schematic diagram illustrating an exemplary encoding process of a hybrid video encoding system consistent with embodiments of the present disclosure. [Figure 2B]

[0012] This schematic diagram shows another exemplary encoding process for a hybrid video encoding system consistent with embodiments of the present disclosure. [Figure 3A]

[0013] This is a schematic diagram illustrating an exemplary decoding process of a hybrid video encoding system consistent with embodiments of the present disclosure. [Figure 3B]

[0014] This schematic diagram shows another exemplary decoding process for a hybrid video encoding system consistent with embodiments of the present disclosure. [Figure 4]

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

[0016] This is a schematic diagram of an exemplary bitstream consistent with some embodiments of the present disclosure. [Figure 6]

[0017] This is a schematic diagram showing the structure of a block-partitioned picture, consistent with some embodiments of the present disclosure. [Figure 7]

[0018] This is a schematic diagram showing the structure of a picture partitioned in raster scan slice mode, consistent with some embodiments of the present disclosure. [Figure 8]

[0019] This is a schematic diagram showing the structure of a picture partitioned in rectangular slice mode, consistent with some embodiments of the present disclosure. [Figure 9]

[0020] This is a schematic diagram showing the structure of a picture partitioned in rectangular slice mode, consistent with some embodiments of the present disclosure. [Figure 10]

[0021] A schematic diagram showing the structure of a picture partitioned in a rectangular slice mode, which conforms to some embodiments of the present disclosure. [Figure 11]

[0022] An exemplary coded syntax table of a part of the SPS syntax structure, which conforms to some embodiments of the present disclosure, is shown. [Figure 12A]

[0023] An exemplary coded syntax table of a part of the PPS syntax structure, which conforms to some embodiments of the present disclosure, is shown. [Figure 12B]

[0023] An exemplary coded syntax table of a part of the PPS syntax structure, which conforms to some embodiments of the present disclosure, is shown. [Figure 13]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 14]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 15]

[0024] Exemplary pseudoccode that conforms to some embodiments of the present disclosure is shown. [Figure 16]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 17]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 18]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 19]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 20]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 21A]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 21B]

[0024] Exemplary pseudocode that conforms to some embodiments of the present disclosure is shown. [Figure 22]

[0024] Exemplary pseudocode consistent with some embodiments of the present disclosure is shown below. [Figure 23]

[0024] Exemplary pseudocode consistent with some embodiments of the present disclosure is shown below. [Figure 24]

[0025] An exemplary coded syntax table of some parts of the SPS syntax structure, consistent with several embodiments of this disclosure, is shown below. [Figure 25]

[0026] Another exemplary coded syntax table of a portion of the SPS syntax structure, consistent with some embodiments of this disclosure, is shown below. [Figure 26]

[0027] Another exemplary coded syntax table of a portion of the SPS syntax structure, consistent with some embodiments of this disclosure, is shown below. [Figure 27A]

[0028] A flowchart illustrating an exemplary video encoding or decoding method, consistent with several embodiments of this disclosure, is shown. [Figure 27B]

[0028] A flowchart of an exemplary video encoding or decoding method consistent with some embodiments of the present disclosure is shown. [Figure 27C]

[0028] A flowchart of an exemplary video encoding or decoding method consistent with some embodiments of the present disclosure is shown. [Figure 28]

[0029] The following are exemplary modified coded syntax tables of some parts of the PPS syntax structure that are consistent with some embodiments of this disclosure. [Figure 29]

[0030] A flowchart illustrating an exemplary video encoding or decoding method, consistent with several embodiments of this disclosure, is shown. [Figure 30]

[0031] The following are exemplary modified coded syntax tables of some parts of the PPS syntax structure that are consistent with some embodiments of this disclosure. [Figure 31A]

[0032] Figure 29 shows exemplary detailed operation of the steps of the method consistent with several embodiments of this disclosure. [Figure 31B]

[0032] The steps of the method shown in Figure 29 are shown in exemplary detail, consistent with some embodiments of the present disclosure. [Figure 32]

[0033] A flowchart illustrating an exemplary video encoding or decoding method, consistent with several embodiments of this disclosure, is shown. [Figure 33]

[0034] Exemplary pseudocode consistent with several embodiments of this disclosure is provided below. [Figure 34A]

[0034] Exemplary pseudocode consistent with some embodiments of the present disclosure is shown below. [Figure 34B]

[0034] Exemplary pseudocode consistent with some embodiments of the present disclosure is shown below. [Figure 34C]

[0034] Exemplary pseudocode consistent with some embodiments of the present disclosure is shown below. [Modes for carrying out the invention]

[0011] Detailed explanation

[0035] Herein, examples will be given in detail to the exemplary embodiments shown in the accompanying drawings. The following description will be given in reference to the accompanying drawings, in which, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The implementations described below in the description of exemplary embodiments will not represent all implementations conforming to the present disclosure. Rather, they will be merely examples of devices and methods conforming to the aspects relating to the present disclosure enumerated in the accompanying claims. Specific aspects of the present disclosure will be described in more detail below. In the event of any conflict between terms and / or definitions used by reference and those given herein, the terms and definitions given herein shall prevail.

[0012]

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

[0013]

[0037] To achieve the same subjective quality as HEVC / H.265 using half the bandwidth, JVET is developing techniques that surpass HEVC using joint exploration model (JEM) reference software. Because coding techniques are incorporated into JEM, JEM has achieved substantially higher coding performance than HEVC.

[0014]

[0038] The VVC standard is a relatively recent development and continues to incorporate more coding technologies that result in better compression performance. VVC is based on the same hybrid video coding system used in modern video compression standards such as HEVC, H.264 / AVC, MPEG2, and H.263.

[0015]

[0039] 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.

[0016]

[0040] 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 one or more processors (e.g., one or more processors in a general-purpose computer) 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 combinations 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. A software implementation of an encoder and decoder may include program code, computer executable instructions, firmware, or algorithms or processes implemented by any appropriate computer fixed in a computer-readable medium. Video compression and decompression can be implemented using 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 then recompress the decompressed video using a second encoding standard; in this case, the codec can be called a "transcoder."

[0017]

[0041] 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.

[0018]

[0042] 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 can reflect the movement of the object between the reference picture and the current picture.

[0019]

[0043] 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 is called a "P-picture" if some or all of the blocks within it (for example, blocks that generally reference a part of a video picture) are predicted using intra-prediction or inter-prediction with one reference picture (e.g., unidirectional prediction). A picture is called a "B-picture" if at least one block within it is predicted using two reference pictures (e.g., bidirectional prediction).

[0020]

[0044] In this disclosure, SPS and PPS syntax elements related to tile / slice partitions can be modified to remove unnecessary constraints or to determine the value of syntax elements that are conditionally signaled, thereby achieving higher coding performance. By adopting these modifications, the consistency and efficiency of the encoding and decoding processes for video streams can be improved.

[0021]

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

[0022]

[0046] 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.

[0023]

[0047] 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.

[0024]

[0048] 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 syntax 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.

[0025]

[0049] Video encoding involves multiple operational stages, examples of which are shown 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, which are referred to in this disclosure as “basic processing subunits.” In some embodiments, a basic processing subunit may be referred to as a “block” within some video encoding standards (e.g., the MPEG family, H.261, H.263, or H.264 / AVC) or as an “encoded unit” (“CU”) within other video encoding standards (e.g., H.265 / HEVC or H.266 / VVC). A basic processing subunit may be the same size as or smaller than a basic processing unit. Similar to a basic processing unit, a basic processing subunit is a logical unit that may contain various types of video data (e.g., Y, Cb, Cr, and associated syntax elements) stored in computer memory (e.g., in a video frame buffer). Any operation performed on the basic processing subunit can be repeated on its luma and chroma components, respectively. It should be noted that such divisions may be performed at further levels as needed. It should also be noted that various stages can divide the basic processing unit using various methods.

[0026]

[0050] For example, in the mode determination stage (an example of which is shown in Figure 2B), the encoder can determine which prediction mode (e.g., intrapicture prediction or interpicture 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.

[0027]

[0051] In another example (shown in Figure 2A-2B), 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" within H.265 / HEVC or H.266 / VVC) and perform prediction operations at that level.

[0028]

[0052] In another example (shown in Figure 2A-2B), 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 for 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.

[0029]

[0053] 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.

[0030]

[0054] 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: "slices" and "tiles." It should also be noted that the various pictures in video sequence 100 may have various division schemes for dividing the picture into regions.

[0031]

[0055] 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.

[0032]

[0056] Figure 2A shows a schematic diagram of an example of an encoding process 200A consistent with embodiments of the present disclosure. For example, the encoding process 200A may be performed by an encoder. As shown in Figure 2A, the encoder can encode a video sequence 202 into a video bitstream 228 according to process 200A. Similar to the video sequence 100 in Figure 1, the video sequence 202 may include a set of pictures (referred to as “original pictures”) arranged in chronological order. Similar to the structure 110 in Figure 1, each original picture in the 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 perform process 200A at the level of a basic processing unit with respect to each original picture in the video sequence 202. For example, the encoder can perform process 200A in an iterative manner, in which case 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 each region of the original picture in the video sequence 202 (e.g., regions 114-118).

[0033]

[0057] 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.

[0034]

[0058] The encoder can iteratively perform process 200A to encode each original BPU of the original picture (in the forward path) and generate a prediction 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.

[0035]

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

[0036]

[0060] In prediction stage 204, in the current iteration, the encoder can receive the original BPU and prediction criterion 224 and 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 of 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.

[0037]

[0061] 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 degrading quality.

[0038]

[0062] 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 "transformation coefficients." 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. No basis pattern 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, where 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.

[0039]

[0063] 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, in which case 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.

[0040]

[0064] 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 can generate quantized conversion coefficients 216 by dividing each conversion coefficient by an integer value (called the "quantization scale factor") and rounding the quotient to its nearest neighbor. After this operation, some conversion coefficients of the high-frequency basis patterns can be converted to zero, and the conversion coefficients of the low-frequency basis patterns can be converted to smaller integers. The encoder can ignore the zero-value quantized conversion coefficients 216, thereby further compressing the conversion coefficients. The quantization process is also reversible, and the quantized conversion coefficients 216 can be reconstructed into conversion coefficients by the inverse operation of quantization (called "inverse quantization").

[0041]

[0065] 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.

[0042]

[0066] 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.

[0043]

[0067] 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.

[0044]

[0068] 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.

[0045]

[0069] 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.

[0046]

[0070] 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.

[0047]

[0071] 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.

[0048]

[0072] 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 the "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 in the reference picture at a location having the same coordinates as the original BPU in the current picture and can be extended over a predetermined distance. When the encoder identifies a region similar to the original BPU within the search window (for example, by using the PEL recursive algorithm, block matching algorithm, etc.), the encoder can determine that region as a match region. The match region may have different dimensions from the original BPU (for example, smaller, equal to, 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 original BPU's position 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 search for 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.

[0049]

[0073] 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.

[0050]

[0074] 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.

[0051]

[0075] 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 (e.g., 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 (e.g., pictures 104 and 108) are in both temporal directions relative to picture 104.

[0052]

[0076] 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.

[0053]

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

[0054]

[0078] 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, in which case 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) encoded within the video bitstream 228.

[0055]

[0079] 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 this 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 a prediction criterion 224. In some embodiments, the prediction criterion 224 may be stored in a buffer (e.g., a decoded picture buffer in computer memory). The decoder can feed the prediction criterion 224 to the prediction stage 204 for performing a prediction operation in the next iteration of process 300A.

[0056]

[0080] The decoder can iteratively perform process 300A to decode each encoded BPU of the encoded picture and generate a predictive 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.

[0057]

[0081] 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 predicted 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.

[0058]

[0082] 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.

[0059]

[0083] 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.

[0060]

[0084] 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.

[0061]

[0085] In process 300B, the decoder can feed the prediction 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 decoder 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 (DPB) 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, the prediction data may further include loop filter parameters (e.g., loop filter strength). In some embodiments, the prediction data includes loop filter parameters when the prediction mode indicator of the prediction data 206 indicates that the inter-prediction was used to encode the current BPU. The picture reconstructed from buffer 234 may also be transmitted to a display such as a TV, PC, smartphone, or tablet viewed by the end user.

[0062]

[0086] 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.

[0063]

[0087] 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.

[0064]

[0088] 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.

[0065]

[0089] 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.

[0066]

[0090] 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 combination of any number of network interface controllers (NICs), radio frequency (RF) modules, transponders, transceivers, modems, routers, gateways, wired network adapters, wireless network adapters, Bluetooth® adapters, infrared adapters, near-field communication ("NFC") adapters, cellular network chips, etc.

[0067]

[0091] 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., a cathode ray tube display, a liquid crystal display, or a light-emitting diode display), a video input device (e.g., a camera or input interface coupled to a video archive), and the like.

[0068]

[0092] 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 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 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 device 400, such as dedicated data processing circuits (e.g., FPGA, ASIC, NPU, etc.).

[0069]

[0093] Figure 5 is a schematic diagram of an example of a bitstream 500 encoded by an encoder, consistent with some embodiments of the present disclosure. In some embodiments, the structure of the bitstream 500 may be applied to the video bitstream 228 shown in Figures 2A-2B and 3A-3B. In Figure 5, the bitstream 500 includes a video parameter set (VPS) 510, a sequence parameter set (SPS) 520, a picture parameter set (PPS) 530, a picture header 540, and slices 550-570, which are separated by synchronization markers M1-M7. Each of the slices 550-570 includes a corresponding header block (e.g., header 552) and a data block (e.g., data 554), and each data block includes one or more CTUs (e.g., CTU1-CTUn in data 554).

[0070]

[0094] According to some embodiments, a bitstream 500, which is a network abstraction layer (NAL) unit or a sequence of bits in the form of a byte stream, forms one or more coded video sequences (CVS). A CVS comprises one or more coded layer video sequences (CLVS). In some embodiments, a CLVS is a sequence of picture units (PUs), each PU containing one coded picture. In particular, a PU contains zero or one picture header NAL unit (e.g., picture header 540), where the picture header NAL unit contains a picture header syntax structure as a payload, one coded picture containing one or more video coded layer (VCL) NAL units, and optionally one or more other non-VCL NAL units. In some embodiments, VCL NAL units are a general term for coded slice NAL units (e.g., slices 550-570) and a subset of NAL units having reserved values ​​of NAL unit types classified as VCL NAL units. A coded slice NAL unit includes a slice header and a slice data block (e.g., header 552 and data 554).

[0071]

[0095] In other words, in some embodiments of the present disclosure, one layer may be a set of video coding layer (VCL) NAL units and associated non-VCL NAL units having a specific value for the NAL layer ID. For these layers, interlayer prediction may be applied between different layers to achieve high compression performance.

[0072]

[0096] As described above, in the multi-purpose video coding (e.g., VVC / H.266) standard, a picture may be partitioned into a set of CTUs, and multiple CTUs may form tiles, slices, or subpictures. When a picture includes three sample arrays for storing three color components (e.g., a luminous component and two chroma components), a CTU may include N × N (where N is an integer) blocks of luminous samples, where each block of luminous samples is associated with two blocks of chroma samples. In some embodiments, an output layer set (OLS) may be designated to support decoding some, but not all, layers. An OLS is a set of layers containing a designated set of layers, where one or more layers within the set of layers are designated as output layers. Thus, an OLS may include one or more output layers and other layers that need to be decoded for inter-layer prediction.

[0073]

[0097] For example, Figure 6 is a schematic diagram showing the structure of a block-partitioned picture 600, consistent with several embodiments of the present disclosure. In Figure 6, each square represents a CTU 610, and the picture 600 is partitioned into an 8x6 CTU 610. In some embodiments, the maximum allowable size of a luma block within a CTU is 128x128, and the maximum allowable size of a luma conversion block is 64x64. In some embodiments, the minimum allowable size of a luma block within a CTU is 32x32. Note that the maximum allowable size of a luma block, the maximum allowable size of a luma conversion block, and the minimum allowable size of a luma block may be specified to have different values ​​and shapes in various video coding standards, and the present disclosure is not limited to the examples described above.

[0074]

[0098] In accordance with some embodiments of the present disclosure, a picture may be partitioned into one or more tile rows and one or more tile columns. “Tiles” in the present disclosure may refer to a sequence of CTUs covering a rectangular area of ​​a picture. “Slices” in the present disclosure may include an integer number of complete tiles, or an integer number of consecutive complete CTU rows within a tile of a picture.

[0075]

[0099] In some embodiments, a picture may be divided into slices in two modes: a "raster scan slice mode" and a "rectangular slice mode." In the raster scan slice mode, a slice of a picture may contain a sequence of complete tiles in the raster scan order of the picture. In the rectangular slice mode, a slice of a picture may contain several complete tiles that collectively form a rectangular region of the picture, or several consecutive complete CTU rows of tiles that collectively form a rectangular region of the picture. The tiles in a rectangular slice may be scanned in raster scan order within the formed rectangular region corresponding to the rectangular slice.

[0076]

[0100] As an example, Figure 7 is a schematic diagram showing the structure of a picture 700 partitioned in raster scan slice mode, consistent with several embodiments of the present disclosure. In Figure 7, each dashed square represents a CTU, and the picture 700 is partitioned into 16 × 14 CTUs. The CTUs of the picture 700 form 12 tiles (e.g., tiles 712-716, 722-726, 732-736, and 742-746) including 4 tile rows and 3 tile columns, and their boundaries are represented by thin solid lines overlapping dashed lines. Furthermore, the picture 700 is divided into three raster scan slices represented by different shades, and their boundaries are represented by thick solid lines overlapping dashed lines or thin solid lines. As shown in Figure 7, the first slice includes tiles 712 and 714. The second slice includes tiles 716, 722-726, and 732-734. The third slice contains tiles 736 and 742-746. The three slices of picture 700 are partitioned in raster scan order, and each of the three slices contains an integer number of complete tiles.

[0077]

[0101] As an example, Figure 8 is a schematic diagram showing the structure of picture 800 partitioned in rectangular slice mode, consistent with several embodiments of the present disclosure. In Figure 8, each dashed square represents a CTU, and picture 800 is partitioned into 16 × 14 CTUs. The CTUs of picture 800 form 12 tiles, each containing 4 tile rows and 5 tile columns, and their boundaries are represented by thin solid lines overlapping the dashed lines. Furthermore, picture 800 is divided into 9 rectangular slices, each represented by a different shade, and their boundaries are represented by thick solid lines overlapping the dashed lines or thin solid lines. As shown in Figure 8, the 9 slices of picture 800 are partitioned into rectangles forming 9 rectangular regions, and each of the 9 slices contains an integer number of complete tiles. For example, the first slice contains tiles 812 and 814. The second slice contains tiles 816 and 818. The third slice contains tile 819. The fourth slice includes tiles 822, 824, 832, and 834. The fifth slice includes tiles 826, 828, 836, and 838. The sixth slice includes tiles 829 and 839. The seventh slice includes tiles 842 and 844. The eighth slice includes tiles 846 and 848. The ninth slice includes tile 849.

[0078]

[0102] As an example, Figure 9 is a schematic diagram showing the structure of a picture 900 partitioned in rectangular slice mode, consistent with several embodiments of the present disclosure. In Figure 9, each dashed square represents a CTU, and the picture 900 is partitioned into 16 × 14 CTUs. The CTUs of the picture 900 form four tiles 910, 920, 930, and 940, each containing two tile rows and two tile columns, and their boundaries are represented by dashed lines. For example, the first tile 910 may be in the upper left with a size of 7 × 10 CTUs. The second tile 920 may be in the lower left with a size of 7 × 4 CTUs. The third tile 930 may be in the upper right with a size of 9 × 10 CTUs. The fourth tile 940 may be in the lower right with a size of 9 × 4 CTUs. Furthermore, the picture 900 is divided into four rectangular slices represented by different shades, and their boundaries are represented by dashed lines or thick solid lines overlapping thin solid lines. As shown in Figure 9, the four slices of picture 900 are partitioned into rectangles that form four rectangular regions, and each of the four slices contains an integer number of complete tiles or an integer number of consecutive complete CTU rows within the tiles of picture 800. For example, the first slice (shown in white) has a size of 7 × 14 CTU and may contain two complete tiles 910 and 920. The second slice (shown in gray) has a size of 9 × 4 CTU and may contain one portion of tile 930 (e.g., portion 932). The third slice (shown in white) has a size of 9 × 6 CTU and may contain another portion of tile 930 (e.g., portion 934). The fourth slice (shown in gray) has a size of 9 × 4 CTU and may contain one complete tile 940.

[0079]

[0103] As an example, Figure 10 is a schematic diagram showing the structure of picture 1000 partitioned in rectangular slice mode, consistent with several embodiments of the present disclosure. In Figure 10, each dashed square represents a CTU, and picture 1000 is partitioned into 16 × 16 CTUs. The CTUs of picture 1000 form 20 tiles 1012-1019, 1022-1029, 1032-1039, and 1042-1049, comprising 4 tile rows and 5 tile columns, with their boundaries represented by thin solid lines overlapping the dashed lines. As shown in Figure 10, the 12 tiles on the left (e.g., tiles 1012-1016, 1022-1026, 1032-1036, and 1042-1046) each cover one slice of 4 × 4 CTUs. The eight tiles on the right (for example, tiles 1018, 1019, 1028, 1029, 1038, 1039, 1048, and 1049) each cover two vertically stacked 2x2 CTU slices, resulting in 28 slices represented by different shades, each of which is a sub-picture. For example, tile 1018 covers vertically stacked slices 1018a and 1018b, tile 1028 covers vertically stacked slices 1028a and 1028b, and so on. The boundaries between slices / sub-pictures are represented by thick dashed lines.

[0080]

[0104] In some embodiments, a subpicture layout or subpicture section may be signaled in a sequence parameter set (SPS). Figure 11 shows an exemplary coded syntax table of a portion of an SPS syntax structure 1100 for signaling a subpicture layout, consistent with some embodiments of the present disclosure. The pseudocode shown in Figure 11 may be part of a VVC standard.

[0081]

[0105] In Figure 11, the SPS flag 1110 ("sps_subpic_info_present_flag") may, when equal to 1, specify that subpicture information exists for CLVSs, and that each picture in the CLVS may have one or more subpictures. Consistent with the above disclosure, a CLVS is a group of pictures belonging to the same layer, beginning with a random access point, followed by mutually dependent pictures and random access point pictures. When the SPS flag 1110 is equal to 0, there is no subpicture information for the CLVS, and each picture in the CLVS has only one subpicture. In some embodiments, the SPS flag "sps_res_change_in_clvs_allowed_flag" being equal to 1 specifies that the value of the SPS flag 1110 is equal to 0. When the bitstream is the result of a sub-bitstream extraction process and contains only a subset of subpictures from the input bitstream to the sub-bitstream extraction process, the value of the SPS flag 1110 may need to be set to 1 in the raw byte sequence payload ("RBSP") of the sequence parameter set ("SPS").

[0082]

[0106] In Figure 11, the SPS syntax element "sps_num_subpics_minus1" (for example, syntax element 1112 in Figure 11) + 1 specifies the number of subpics within each picture in CLVS. The value of syntax element 1112 ("sps_num_subpics_minus1") is between 0 and (ceil(sps_pic_width_max_in_luma_samples÷CtbSizeY)×ceil(sps_pic_height_max_in_luma_samples÷CtbSizeY)-1). If it does not exist, the value of syntax element 1112 ("sps_num_subpics_minus1") is determined to be equal to 0.

[0083]

[0107] In Figure 11, when the SPS flag 1120 ("sps_independent_subpics_flag") is equal to 1, it may specify that all subpicture boundaries within the CLVS are treated as picture boundaries, and that there is no loop filtering across subpicture boundaries. When the SPS flag 1120 is equal to 0, no such constraint is imposed. If the value of the SPS flag 1120 is not present, it is determined to be equal to 1.

[0084]

[0108] In Figure 11, the SPS syntax element "sps_subpic_ctu_top_left_x[i]" (for example, syntax element 1122 in Figure 11) specifies the horizontal position of the top-left CTU of the i-th subpicture in units of CtbSizeY. The length of this syntax element 1122 is ceil(log2((sps_pic_width_max_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY)) bits. The value of the SPS syntax element "sps_subpic_ctu_top_left_x[i]" is considered equal to 0 if it does not exist.

[0085]

[0109] Similarly, the SPS syntax element "sps_subpic_ctu_top_left_y[i]" (for example, syntax element 1124 in Figure 11) specifies the vertical position of the top-left CTU of the i-th subpicture in units of CtbSizeY. The length of this syntax element 1124 is ceil(log2((sps_pic_height_max_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY)) bits. The value of the SPS syntax element "sps_subpic_ctu_top_left_y[i]" is considered equal to 0 if it does not exist.

[0086]

[0110] In Figure 11, the SPS syntax element "sps_subpic_width_minus1[i]" (for example, syntax element 1126 in Figure 11) + 1 specifies the width of the i-th subpicture in units of CtbSizeY. The length of this syntax element 1126 is ceil(log2((sps_pic_width_max_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY)) bits. If it does not exist, the value of the SPS syntax element "sps_subpic_width_minus1[i]" is determined to be equal to ((ps_pic_width_max_in_luma_samples+CtbSizeY-1)>>(CtbLog2SizeY)-sps_subpic_ctu_top_left_x[i]-1).

[0087]

[0111] Similarly, the SPS syntax element "sps_subpic_height_minus1[i]" (e.g., syntax element 1128 in Figure 11) + 1 specifies the height of the i-th subpicture in units of CtbSizeY. The length of this syntax element 1128 is ceil(log2((sps_pic_height_max_in_luma_samples+CtbSizeY-1)>>CtbLog2SizeY)) bits. If it does not exist, the value of the SPS syntax element "sps_subpic_height_minus1[i]" is determined to be equal to ((sps_pic_height_max_in_luma_samples+CtbSizeY-1)>>(CtbLog2SizeY)-sps_subpic_ctu_top_left_y[i]-1).

[0088]

[0112] In some embodiments, in order to satisfy bitstream compatibility, the shape of the subpicture is such that each subpicture has its entire left boundary and its entire top boundary, which include the picture boundary or the boundary of a previously decoded subpicture at the time of decoding.

[0089]

[0113] In some embodiments, for each subpicture having a subpicture index i in the range of 0 or greater and less than or equal to the value of syntax element 1112, the following conditions must be true in order to satisfy bitstream compatibility: Firstly, the value of (sps_subpic_ctu_top_left_x[i] × CtbSizeY) is less than (sps_pic_width_max_in_luma_samples - sps_conf_win_right_offset × SubWidthC). Secondly, the value of ((sps_subpic_ctu_top_left_x[i] + sps_subpic_width_minus1[i] + 1) × CtbSizeY) is greater than (sps_conf_win_left_offset × SubWidthC). Thirdly, the value of (sps_subpic_ctu_top_left_y[i] × CtbSizeY) is less than (sps_pic_height_max_in_luma_samples - sps_conf_win_bottom_offset × SubHeightC). Fourthly, the value of ((sps_subpic_ctu_top_left_y[i] + sps_subpic_height_minus1[i] + 1) × CtbSizeY) is greater than (sps_conf_win_top_offset × SubHeightC).

[0090]

[0114] In Figure 11, the SPS flag 1130 ("sps_subpic_treated_as_pic_flag[i]") may, when equal to 1, specify that the i-th subpicture of each coded picture in the CLVS is treated as a picture during the decoding process, excluding in-loop filtering. An SPS flag 1130 equal to 0 specifies that the i-th subpicture of each coded picture in the CLVS is not treated as a picture during the decoding process, excluding in-loop filtering. If it does not exist, the value of the SPS flag 1130 is determined to be equal to 1.

[0091]

[0115] When the value of the SPS syntax element "sps_num_subpics_minus1" (for example, syntax element 1112 in Figure 11) is greater than 0 and the SPS flag 1130 is equal to 1, for each CLVS of the current layer referencing the SPS, the target set of AUs ("targetAuSet") refers to all access units ("AUs"), starting from the AU containing the first picture of the CLVS in decoded order and including the AU containing the last picture of the CLVS in decoded order. In some embodiments, in order to satisfy bitstream compatibility, the following conditions must be true for the target set of layers ("targetLayerSet"), including the current layer and layers that use the current layer as a base layer: Firstly, for each AU in targetAuSet, all pictures of the layer in targetLayerSet have the same values ​​for pps_pic_width_in_luma_samples and the same values ​​for pps_pic_height_in_luma_samples. Secondly, all SPS referenced by layers in targetLayerSet have the same syntax element 1112, and for each value of j in the range from 0 to syntax element 1112, they have the same sps_subpic_ctu_top_left_x[j], sps_subpic_ctu_top_left_y[j], sps_subpic_width_minus1[j], sps_subpic_height_minus1[j], and sps_subpic_treated_as_pic_flag[j]. Thirdly, for each AU in targetAuSet, all pictures of layers in targetLayerSet have the same SubpicIdVal[j] for each value of j in the range of j in the range from 0 to syntax element 1112.

[0092]

[0116] In Figure 11, flag 1140 ("sps_loop_filter_across_subpic_enabled_flag[i]"), when equal to 1, specifies that in-loop filtering across subpicture boundaries is enabled and can be performed across the boundary of the i-th subpicture within each coded picture in the CLVS. Flag 1140, when equal to 0, specifies that in-loop filtering across subpicture boundaries is disabled and will not be performed across the boundary of the i-th subpicture within each coded picture in the CLVS. If the value of flag 1140 is not present, it is determined to be equal to 0.

[0093]

[0117] The SPS syntax element "sps_subpic_id_len_minus1" (for example, syntax element 1142 in Figure 11) + 1 specifies the number of bits used to represent the SPS syntax element "sps_subpic_id[i]", the PPS syntax element "pps_subpic_id[i]" if present, and the syntax element "sh_subpic_id" if present. In some embodiments, the value of the SPS syntax element "sps_subpic_id_len_minus1" is in the range of 0 to 15. The value of 1 << (sps_subpic_id_len_minus1 + 1) is greater than or equal to sps_num_subpics_minus1 + 1.

[0094]

[0118] In Figure 11, flag 1150 ("sps_subpic_id_mapping_explicitly_signalled_flag"), when equal to 1, specifies that subpicture ID mapping is explicitly signaled in either the SPS or PPS referenced by the coded picture in the CLVS. Flag 1150, when equal to 0, specifies that subpicture ID mapping is not explicitly signaled for the CLVS. If the value of flag 1150 does not exist, it is determined to be equal to 0.

[0095]

[0119] In Figure 11, flag 1160 ("sps_subpic_id_mapping_present_flag"), when equal to 1, specifies that subpicture ID mapping is signaled in the SPS when flag 1150 is equal to 1. Flag 1160, when equal to 0, specifies that subpicture ID mapping is signaled in the PPS referenced by the coded picture in the CLVS when flag 1150 is equal to 1.

[0096]

[0120] The SPS syntax element "sps_subpic_id[i]" (for example, syntax element 1162 in Figure 11) specifies the subpicture ID of the i-th subpicture. In some embodiments, the length of the SPS syntax element "sps_subpic_id[i]" is a value of "sps_subpic_id_len_minus1" + 1 bits.

[0097]

[0121] In some embodiments, tile mapping information for tiles and slice parcels may be signaled in the Picture Parameter Set (PPS). Figure 12 shows an exemplary coded syntax table of a portion of the PPS syntax structure 1200 for signaling tile mapping and slices within tile mapping, consistent with some embodiments of the present disclosure. The pseudocode shown in Figure 12 may be part of the VVC standard.

[0098]

[0122] In Figure 12, the PPS flag 1210 ("pps_no_pic_partition_flag") may specify that when the PPS flag 1210 is equal to 1, no picture partition is applied to any picture that references a PPS (including the PPS flag 1210), and when the PPS flag 1210 is equal to 0, each picture that references a PPS may be partitioned into one or more tiles or slices. In some embodiments, the bitstream compatibility requirement is that the value of the PPS flag 1210 is the same for all PPS referenced by coded pictures in a coded layer video sequence (CLVS). In some embodiments, the bitstream compatibility requirement is also that the value of the PPS flag 1210 is equal to 0 when the value of syntax element 1112 ("sps_num_subpics_minus1") is greater than 0, or when the value of syntax element "pps_mixed_nalu_types_in_pic_flag" is equal to 1.

[0099]

[0123] In Figure 12, a value of flag 1220 ("pps_subpic_id_mapping_present_flag") equal to 1 indicates that the subpicture ID mapping is signaled in the PPS. A value of flag 1220 equal to 0 indicates that the subpicture ID mapping is not signaled in the PPS. In some embodiments, if the SPS flag "sps_subpic_id_mapping_explicitly_signalled_flag" (e.g., flag 1150) is equal to 0, or if the SPS flag "sps_subpic_id_mapping_present_flag" (e.g., flag 1160) is equal to 1, then the value of flag 1220 is equal to 0. If the SPS flag 1150 is equal to 1 and the SPS flag 1160 is equal to 0, then the value of flag 1220 is equal to 1.

[0100]

[0124] In Figure 12, the value of the syntax element "pps_num_subpics_minus1" (for example, syntax element 1222 in Figure 12) is equal to the value of the SPS syntax element "sps_num_subpics_minus1" (for example, syntax element 1112 in Figure 11). When the PPS flag 1210 is equal to 1, the value of syntax element 1222 is determined to be equal to 0.

[0101]

[0125] In Figure 12, the value of the syntax element "pps_subpic_id_len_minus1" (for example, syntax element 1224 in Figure 12) is equal to the value of the SPS syntax element "sps_subpic_id_len_minus1" (for example, syntax element 1142 in Figure 11).

[0102]

[0126] In Figure 12, the value of the syntax element "pps_subpic_id[i]" (for example, syntax element 1226 in Figure 12) specifies the subpicture ID of the i-th subpicture. In some embodiments, the length of syntax element 1226 is pps_subpic_id_len_minus1+1 bits.

[0103]

[0127] Figure 13 shows exemplary pseudocode for deriving a value for the variable SubpicIdVal according to some embodiments of the present disclosure. As shown in Figure 13, a value for the variable SubpicIdVal can be derived for each value of index i in the range of 0 or greater and less than or equal to syntax element 1112 ("sps_num_subpics_minus1"). In some embodiments, both of the following constraints apply to satisfy bitstream compatibility. First, for any two different values ​​of index i and index j in the range of 0 or greater and less than or equal to syntax element 1112 ("sps_num_subpics_minus1"), SubpicIdVal[i] is not equal to SubpicIdVal[j]. Secondly, for each index i in the range of 0 or greater and less than or equal to syntax element 1112 ("sps_num_subpics_minus1"), if the value of SubpicIdVal[i] of the current picture having a nuh_layer_id equal to a particular value layerId is not equal to the value of SubpicIdVal[i] of the reference picture having a nuh_layer_id equal to layerId, then the active entry in the reference picture list ("RPL") of the coded slice in the i-th subpicture of the current picture does not include that reference picture.

[0104]

[0128] In Figure 12, the value of the syntax element "pps_log2_ctu_size_minus5" (e.g., syntax element 1228 in Figure 12) + 5 specifies the luma-coded tree block size for each CTU. In some embodiments, syntax element 1228 is equal to the syntax element "sps_log2_ctu_size_minus5" signaled in the SPS.

[0105]

[0129] In Figure 12, the value of the syntax element "pps_num_exp_tile_columns_minus1" (e.g., syntax element 1232 in Figure 12) + 1 specifies the number of tile column widths that are explicitly given. In some embodiments, the value of syntax element 1232 is in the range of 0 or greater and (PicWidthInCtbsY-1) or less. When the PPS flag 1210 is equal to 1, the value of syntax element 1232 is determined to be 0.

[0106]

[0130] In Figure 12, the value of the syntax element "pps_num_exp_tile_rows_minus1" (e.g., syntax element 1234 in Figure 12) + 1 specifies the number of tile row heights that are explicitly given. In some embodiments, the value of syntax element 1234 is in the range of 0 or greater and (PicHeightInCtbsY-1) or less. When the PPS flag 1210 is equal to 1, the value of syntax element 1234 is determined to be 0.

[0107]

[0131] In Figure 12, the value of the syntax element "pps_tile_column_width_minus1[i]" (e.g., syntax element 1236 in Figure 12) + 1 specifies the width of the i-th tile column in the CTB unit, where the index i is in the range of 0 or greater and less than or equal to syntax element 1232. In some embodiments, the syntax element "pps_tile_column_width_minus1[num_exp_tile_columns_minus1]" may be used to derive the width of a tile column with an index greater than syntax element 1232, as specified herein. The value of syntax element 1236 is in the range of 0 or greater and less than or equal to (PicWidthInCtbsY-1). The value of the syntax element "pps_tile_column_width_minus1[0]" is determined to be equal to "PicWidthInCtbsY-1" if it does not exist in the PPS.

[0108]

[0132] In Figure 12, the value of the syntax element "pps_tile_row_height_minus1[i]" (e.g., syntax element 1238 in Figure 12) + 1 specifies the height of the i-th tile row in the CTB unit, where the index i is in the range of 0 or greater and less than or equal to syntax element 1234. In some embodiments, the syntax element "pps_tile_row_height_minus1[pps_num_exp_tile_rows_minus1]" may be used to derive the height of a tile row with an index greater than syntax element 1234, as specified herein. The value of 1238 is in the range of 0 or greater and less than or equal to (PicHeightInCtbsY-1). The value of the syntax element "pps_tile_row_height_minus1[0]" is determined to be equal to "PicHeightInCtbsY-1" when it does not exist in the PPS.

[0109]

[0133] In Figure 12, flag 1230 ("pps_loop_filter_across_tiles_enabled_flag"), when equal to 1, specifies that in-loop filtering across tile boundaries is enabled and can be performed across tile boundaries in pictures referencing the PPS. When flag 1230 is equal to 0, specifies that in-loop filtering across tile boundaries is disabled and will not be performed across tile boundaries in pictures referencing the PPS. In-loop filtering includes deblocking filters, sample adaptive offset filters, and adaptive loop filtering. The value of flag 1230 is considered equal to 1 when it does not exist.

[0110]

[0134] In Figure 12, when flag 1240 ("pps_rect_slice_flag") is equal to 0, it specifies that the tiles within each slice are in raster scan order and that slice information is not signaled in PPS. When flag 1240 is equal to 1, it specifies that the tiles within each slice cover the rectangular area of ​​the picture and that slice information is signaled in PPS. Flag 1240 may be determined to be equal to 1 if it is not present in PPS. In some embodiments, the value of flag 1240 is equal to 1 when SPS flag 1110 ("sps_subpic_info_present_flag") is equal to 1 or when PPS flag "pps_mixed_nalu_types_in_pic_flag" is equal to 1.

[0111]

[0135] In Figure 12, flag 1250 ("pps_single_slice_per_subpic_flag"), when equal to 0, specifies that each subpicture may contain one or more rectangular slices. Flag 1250, when equal to 1, specifies that each subpicture contains one single rectangular slice. Flag 1250 is considered equal to 1 when it is not present.

[0112]

[0136] In Figure 12, the syntax element "pps_num_slices_in_pic_minus1" (e.g., syntax element 1252 in Figure 12) + 1 specifies the number of rectangular slices in each picture that references the PPS. In some embodiments, the value of syntax element 1252 ("pps_num_slices_in_pic_minus1") is in the range of 0 or greater and (value of syntax element "MaxSlicesPerPicture" - 1). The syntax element "MaxSlicesPerPicture" indicates a level limit on the maximum number of slices allowed in a picture. When the PPS flag 1210 is equal to 1, the value of syntax element 1252 ("pps_num_slices_in_pic_minus1") is determined to be equal to 0. That is, no picture partition is applied to any picture that references the PPS, and therefore the picture contains a single slice.

[0113]

[0137] When the PPS flag 1250 is equal to 1, the value of syntax element 1252 ("pps_num_slices_in_pic_minus1") is determined to be equal to the value of syntax element 1112 ("sps_num_subpics_minus1") in the SPS. That is, each subpicture contains a single rectangular slice, and therefore the number of rectangular slices in each picture is equal to the number of subpictures in each picture.

[0114]

[0138] In Figure 12, flag 1260 ("pps_tile_idx_delta_present_flag"), when equal to 0, specifies that the syntax element of pps_tile_idx_delta_val[i] does not exist in the PPS, and that the picture referencing the PPS is partitioned into rectangular slice rows and columns in raster scan order. When flag 1260 is equal to 1, specifies that the syntax element of pps_tile_idx_delta_val[i] may exist in the PPS, and that the rectangular slices in the picture referencing the PPS are specified in the order indicated by the value of the syntax element of pps_tile_idx_delta_val[i] as the value of index i increases. The value of flag 1260 is determined to be equal to 0 when it does not exist.

[0115]

[0139] In Figure 12, the syntax element "pps_slice_width_in_tiles_minus1[i]" (for example, syntax element 1262 in Figure 12) + 1 specifies the width of the i-th rectangular slice of the tile column unit. In some embodiments, the value of syntax element 1262 ("pps_slice_width_in_tiles_minus1[i]") is in the range of 0 or greater and ("NumTileColumns-1" or less). The value of syntax element 1262 ("pps_slice_width_in_tiles_minus1") is determined to be equal to 0 if it does not exist in the PPS.

[0116]

[0140] In Figure 12, the syntax element "pps_slice_height_in_tiles_minus1[i]" (e.g., syntax element 1264 in Figure 12) + 1 specifies the height of the i-th rectangular slice of the tile row unit. In some embodiments, the value of syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") is in the range of 0 or greater and (NumTileRow-1) or less. If syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") does not exist in PPS, and the value of "SliceTopLeftTileIdx[i] / NumTileColumns" is equal to the value of "NumTileRows-1", then the value of syntax element 1264 is determined to be equal to 0; otherwise, the value of syntax element 1264 is determined to be equal to the value of "pps_slice_height_in_tiles_minus1[i-1]".

[0117]

[0141] In Figure 12, the value of the syntax element "pps_num_exp_slices_in_tile[i]" (e.g., syntax element 1266 in Figure 12) specifies the number of slice heights explicitly given to the slices in the current tile (e.g., the tile containing the i-th slice). In some embodiments, the value of syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is in the range of 0 or greater and (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1). If the value of syntax element 1266 does not exist, it is determined to be equal to 0. When syntax element 1266 is equal to 0, the value of the variable "NumSlicesInTile[i]" is derived to be equal to 1, indicating that the tile containing the i-th slice is not divided into multiple slices. When syntax element 1266 is greater than 0, the tile containing the i-th slice may be divided into multiple slices.

[0118]

[0142] In Figure 12, the value of the syntax element "pps_exp_slice_height_in_ctus_minus1[i][j]" (for example, syntax element 1268 in Figure 12) + 1 specifies the height of the j-th rectangular slice in the tile containing the i-th slice of the unit of the CTU row. When syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is greater than 0 (i.e., the tile can be divided into multiple slices), the index j is in the range of 0 or greater and (pps_num_exp_slices_in_tile[i]-1).

[0119]

[0143] The value of the syntax element "pps_exp_slice_height_in_ctus_minus1[i][pps_num_exp_slices_in_tile[i]]" is also used to derive the height of a rectangular slice in a tile containing the i-th slice having an index greater than (pps_num_exp_slices_in_tile[i]-1), as specified herein. The value of syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") shall be in the range of 0 or greater and less than or equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1). That is, the maximum possible height of any rectangular slice in a tile should be the height of the current tile.

[0120]

[0144] In Figure 12, the syntax element "pps_tile_idx_delta_val[i]" (for example, syntax element 1272 in Figure 12) specifies the difference between the tile index of the tile containing the first CTU in the (i+1)th rectangular slice and the tile index of the tile containing the first CTU in the ith rectangular slice. The value of syntax element 1272 ("pps_tile_idx_delta_val[i]") must be in the range of (-NumTilesInPic+1) or greater and (NumTilesInPic-1) or less. If the value of syntax element 1272 does not exist, it is judged to be equal to 0. If the value of syntax element 1272 exists, it is not equal to 0.

[0121]

[0145] In some embodiments, when flag 1240 is equal to 1, the bitstream conformance requirement is that for any two slices belonging to the same picture and different subpictures and having picture-level slice indices idxA and idxB, the value of idxA is less than idxB when SubpicIdxForSlice[idxA] is less than SubpicIdxForSlice[idxB].

[0122]

[0146] In Figure 12, flag 1270 ("pps_loop_filter_across_slices_enabled_flag"), when equal to 1, specifies that in-loop filtering across slice boundaries is enabled and can be performed across slice boundaries in pictures referencing the PPS. When flag 1270 is equal to 0, specifies that in-loop filtering across slice boundaries is disabled and will not be performed across slice boundaries in pictures referencing the PPS. In-loop filtering includes deblocking filters, sample adaptive offset filters, and adaptive loop filtering. The value of flag 1270 is considered equal to 0 when it does not exist.

[0123]

[0147] A variable NumTileColumns can be derived that specifies the number of tile columns, and a list colWidth[i] can be derived for i in the range of 0 to (NumTileColumns-1) that specifies the width of the i-th tile column of the CTB unit. Figure 14 shows exemplary pseudocode, including the derivation of the variable NumTileColumns, according to some embodiments of the present disclosure.

[0124]

[0148] A variable NumTileRows can be derived that specifies the number of tile rows, and a list RowHeight[j] can be derived for j in the range of 0 to (NumTileRows-1) that specifies the height of the j-th tile row of the CTB unit. Figure 15 shows exemplary pseudocode including the derivation of the variable NumTileRows according to some embodiments of the present disclosure. The variable NumTilesInPic is set to equal NumTileColumns × NumTileRows.

[0125]

[0149] A list tileColBd[i] can be derived for i in the range from 0 to NumTileColumns, specifying the position of the i-th tile column boundary of a unit of CTB. Figure 16 shows exemplary pseudocode including the derivation of the variable tileColBd[i] according to some embodiments of the present disclosure. As shown in Figure 16, the size of the array tileColBd[] is 1 greater than the actual number of tile columns.

[0126]

[0150] A list tileRowBd[j] can be derived for j in the range of 0 to NumTileRows, specifying the position of the j-th tile row boundary of a unit of CTB. Figure 17 shows exemplary pseudocode including the derivation of the variable tileRowBd[j] according to some embodiments of the present disclosure. As shown in Figure 17, the size of the array tileRowBd[] is 1 greater than the actual number of tile rows.

[0127]

[0151] A list of ctbAddrX in the range of 0 or greater and less than or equal to PicWidthInCtbsY, CtbToTileColBd[ctbAddrX] and ctbToTileColIdx[ctbAddrX] can be derived, specifying the conversion from a horizontal CTB address to the left tile column boundary and the tile column index within the CTB unit, respectively. Figure 18 shows exemplary pseudocode including the derivation of the variables CtbToTileColBd and ctbToTileColIdx according to some embodiments of the present disclosure. As shown in Figure 18, the size of the arrays CtbToTileColBd[] and ctbToTileColIdx[] is 1 greater than the actual picture width within the CTB.

[0128]

[0152] A list of ctbAddrY in the range of 0 to PicHeightInCtbsY, CtbToTileRowBd[ctbAddrY] and ctbToTileRowIdx[ctbAddrY] can be derived, specifying the conversion from a vertical CTB address to the upper tile column boundary and the tile row index within the CTB unit, respectively. Figure 19 shows exemplary pseudocode including the derivation of the variables CtbToTileRowBd and ctbToTileRowIdx according to some embodiments of the present disclosure. As shown in Figure 19, the size of the arrays CtbToTileRowBd[] and ctbToTileRowIdx[] is 1 greater than the actual picture height in the CTB.

[0129]

[0153] Lists SubpicWidthInTiles[i] and SubpicHeightInTiles[i] can be derived for i in the range of 0 to 1112 ("sps_num_subpics_minus1"), which specify the width and height of the i-th subpicture of a tile column and row, respectively, and a list subpicHeightLessThanOneTileFlag[i] can be derived for i in the range of 0 to 1112 ("sps_num_subpics_minus1"), which specifies whether the height of the i-th subpicture is less than one tile row. Figure 20 shows exemplary pseudocode including the derivation of the variables SubpicWidthInTiles and SubpicHeightInTiles according to some embodiments of the present disclosure. As shown in Figure 20, when a tile is partitioned into multiple rectangular slices and only a subset of the rectangular slices of the tile is contained in the i-th subpicture, the tile is counted as one tile by the value of SubpicHeightInTiles[i].

[0130]

[0154] When flag 1240 ("pps_rect_slice_flag") is equal to 1, a list NumCtusInSlice[i] specifies the number of CTUs in the i-th slice, ranging from 0 to 1252 ("pps_num_slices_in_pic_minus1"), and a list Sli specifies the tile index of the tile containing the first CTU in the slice, ranging from 0 to 1252 ("pps_num_slices_in_pic_minus1"). The following can be derived: ceTopLeftTileIdx[i], a matrix CtbAddrInSlice[i][j] for i (inclusive of 0 and less than or equal to syntax element 1252 ("pps_num_slices_in_pic_minus1")) and j (inclusive of 0 and less than or equal to (NumCtusInSlice[i]-1)), which specifies the picture raster scan address of the j-th CTB in the i-th slice, and the variable NumSlicesInTile[i], which specifies the number of slices in the tile containing the i-th slice. Figures 21 and 22 show exemplary pseudocode including the derivation of the variables NumCtusInSlice, SliceTopLeftTileIdx, CtbAddrInSlice, and NumSlicesInTile according to some embodiments of the present disclosure.

[0131]

[0155] To satisfy bitstream compatibility, the value of NumCtusInSlice[i] for i in the range of 0 or greater and less than or equal to syntax element 1252 ("pps_num_slices_in_pic_minus1") is greater than 0. In addition, to satisfy bitstream compatibility, the matrix CtbAddrInSlice[i][j] for i in the range of 0 or greater and less than or equal to syntax element 1252 ("pps_num_slices_in_pic_minus1") and j in the range of 0 or greater and less than or equal to (NumCtusInSlice[i]-1) contains each of the CTB addresses in the range of 0 or greater and less than or equal to (PicSizeInCtbsY-1) exactly once.

[0132]

[0156] The lists NumSlicesInSubpic[i], SubpicLevelSliceIdx[j], and SubpicIdxForSlice[j] can be derived, specifying the number of slices in the i-th subpicture, the subpicture-level slice index of the slice having picture-level slice index j, and the subpicture index of the slice having picture-level slice index j, respectively. Figure 23 shows exemplary pseudocode, including the derivation of the variables NumSlicesInSubpic, SubpicLevelSliceIdx, and SubpicIdxForSlice, according to some embodiments of the present disclosure.

[0133]

[0157] Embodiments of this disclosure provide signaling a flag in the SPS indicating whether a picture in the current CLVS is partitioned into one or more tiles or slices, and signaling a flag in the PPS having the same value as the flag signaled in the SPS. Figure 24 shows, in bold, an exemplary coded syntax table of a portion of the SPS syntax structure 2400 that is signaled in the SPS, consistent with several embodiments of this disclosure. The syntax structure 2400 is modified based on the syntax 1100 in Figure 11. As shown in Figure 24, changes from the earlier syntax shown in Figure 11 are indicated by a highlighted pattern.

[0134]

[0158] Compared to the SPS syntax shown in Figure 11, in some embodiments, the SPS flag 2410 ("sps_no_pic_partition_flag") is signaled before the SPS flag 1110 in the SPS syntax shown in Figure 24. The SPS flag 2410 ("sps_no_pic_partition_flag") equal to 1 specifies that no picture partition is applied to each picture that references the SPS. The SPS flag 2410 equal to 0 specifies that each picture that references the SPS may be partitioned into one or more tiles or slices.

[0135]

[0159] In some embodiments, one or more additional constraints related to the syntax shown in Figure 24 may be introduced. For example, an additional constraint may be that the value of flag 1210 ("pps_no_pic_partition_flag") signaled in the PPS is equal to the value of SPS flag 2410 ("sps_no_pic_partition_flag") in the associated SPS.

[0136]

[0160] In addition, another constraint may be added to ensure that the value of syntax element 1112 ("sps_num_subpics_minus1") is 0 when the value of SPS flag 2410 is equal to 1. Since a subpicture is a set of slices, when there are no slice partitions (e.g., the SPS syntax element flag is 1), there will be no subpicture partitions (e.g., SPS syntax element 1112 is 0).

[0137]

[0161] Figure 25 shows, in bold, another exemplary coded syntax table of a portion of the SPS syntax structure 2500 signaled in SPS, consistent with several embodiments of this disclosure. Syntax structure 2500 is also modified based on syntax structure 1100 of Figure 11. As shown in Figure 25, changes from the earlier syntax shown in Figure 11 are indicated by a highlighted pattern.

[0138]

[0162] As described above, in some embodiments, when the SPS flag 2410 ("sps_no_pic_partitoin_flag") is equal to 1, there may be only one subpicture. Accordingly, the SPS flag 1110 ("sps_subpic_info_present_flag") or the SPS syntax element 1112 ("sps_num_subpics_minus1") may be conditionally signaled based on the value of the SPS flag 2410 ("sps_no_pic_partitoin_flag"). For example, as shown in Figure 25, the SPS flag 1110 ("sps_subpic_info_present_flag") is signaled when the SPS flag 2410 ("sps_no_pic_partitoin_flag") is equal to 0, and the signaling of the SPS flag 1110 ("sps_subpic_info_present_flag") may be skipped when the SPS flag 2410 ("sps_no_pic_partitoin_flag") is equal to 1. When the signaling of the SPS flag 1110 is skipped, the value of the SPS flag 1110 ("sps_subpic_info_present_flag") may be determined to be 0. In other words, when SPS does not allow a picture partition, there is no subpicture information.

[0139]

[0163] In the syntax of Figure 25, an SPS flag 2410 equal to 1 ("sps_no_pic_partition_flag") specifies that no picture partition is applied to each picture that references the SPS. An SPS flag 2410 equal to 0 specifies that each picture that references the SPS may be partitioned into more than one tile or slice. In the syntax of Figure 25, an SPS flag 1110 equal to 1 ("sps_subpic_info_present_flag") specifies that subpicture information exists for the CLVS, and each picture in the CLVS may have one or more subpictures. An SPS flag 1110 equal to 0 ("sps_subpic_info_present_flag") specifies that subpicture information does not exist for the CLVS, and each picture in the CLVS has only one subpicture. The value of SPS flag 1110 ("sps_subpic_info_present_flag") may be determined to be equal to 0 if it does not exist.

[0140]

[0164] Figure 26 shows, in bold, another exemplary coded syntax table of a portion of the SPS syntax structure 2600 signaled in SPS, consistent with several embodiments of this disclosure. The syntax structure 2600 is also modified based on the syntax structure 1100 of Figure 11. As shown in Figure 26, changes from the earlier syntax shown in Figure 11 are indicated by a highlighted pattern.

[0141]

[0165] As shown in Figure 26, in some embodiments, the SPS flag 1112 ("sps_num_subpics_minus1") is signaled when flag 1110 is equal to 1 and SPS flag 2410 is equal to 0. In other words, the signaling of SPS flag 1112 ("sps_num_subpics_minus1") is skipped when SPS flag 2410 ("sps_no_pic_partitoin_flag") is equal to 1. As mentioned above, when the value of SPS flag 2410 is 1, the value of SPS flag 1112 ("sps_num_subpics_minus1") is determined to be 0 and indicates so. In other words, when SPS does not allow picture partitioning, the number of subpictures can be only one.

[0142]

[0166] In the syntax of Figure 26, an SPS flag 2410 equal to 1 ("sps_no_pic_partitoin_flag") specifies that no picture partition is applied to each picture that references an SPS. An SPS flag 2410 equal to 0 specifies that each picture that references an SPS may be partitioned into more than one tile or slice. In the syntax of Figure 26, an SPS flag 1112 ("sps_num_subpics_minus1") + 1 specifies the number of subpictures within each picture in the CLVS. The value of the SPS flag 1112 ("sps_num_subpics_minus1") is between 0 and (Ceil(sps_pic_width_max_in_luma_samples÷CtbSizeY)×Ceil(sps_pic_height_max_in_luma_samples÷CtbSizeY)-1). The value of SPS flag 1112 ("sps_num_subpics_minus1") may be determined to be equal to 0 if it does not exist.

[0143]

[0167] In some embodiments, the constraint that the value of the PPS flag 1210 ("pps_no_pic_partition_flag") must be the same for all PPS referenced by coded pictures in the CLVS may be removed. In other words, for pictures in the same CLVS, different PPS may independently signal PPS flag 1210 ("pps_no_pic_partition_flag") with different values. As a result, it is possible to have several pictures in a single CLVS that have a PPS flag 1210 ("pps_no_pic_partition_flag") equal to 1 and are not partitioned into multiple slices or tiles, and several other pictures that have a PPS flag 1210 ("pps_no_pic_partition_flag") equal to 0 and are partitioned into one or more tiles or slices. Therefore, the constraint that the value of PPS flag 1210 ("pps_no_pic_partition_flag") must be the same for all PPS referenced by coded pictures in CLVS can be removed.

[0144]

[0168] Figures 27A to 27C show flowcharts of exemplary video coding or decoding methods 2700A, 2700B, and 2700C, respectively, which are consistent with some embodiments of the present disclosure. By applying any of the video coding or decoding methods 2700A, 2700B, and 2700C, one or more SPS syntax elements or flags may be conditionally signaled based on the values ​​of other SPS syntax elements or flags, thereby reducing the number of output bits and achieving higher coding performance. When not signaled in SPS, the value of an SPS syntax element or flag may be determined or assigned accordingly. In some embodiments, methods 2700A to 2700C may be performed by an encoder (e.g., an encoder performing process 200A in Figure 2A or process 200B in Figure 2B) or a decoder (e.g., a decoder performing decoding process 300A in Figure 3A or decoding process 300B in Figure 3B) to generate or decode the bitstream 500 shown in Figure 5. For example, the encoder or decoder may be implemented as one or more software or hardware components of a device (e.g., device 400 in Figure 4) for encoding or transcoding a video sequence (e.g., video sequence 202 in Figure 2A or Figure 2B) to generate a bitstream for the video sequence (e.g., video bitstream 228 in Figure 2A or Figure 2B), or for decoding a bitstream (e.g., video bitstream 228 in Figure 3A or Figure 3B) to reconstruct a video stream of the bitstream (e.g., video stream 304 in Figure 3A or Figure 3B). For example, one or more processors (e.g., processor 402 in Figure 4) may perform methods 2700A to 2700C.

[0145]

[0169] The syntax structure 2400 shown in Figure 24 may be applied to method 2700A. In step 2710, the apparatus is configured to encode or decode an SPS flag 2410 ("sps_no_pic_partition_flag") in the bitstream sequence parameter set (SPS). The SPS flag 2410 indicates whether one or more pictures in the coded layer video sequence (CLVS) referencing the SPS can be partitioned into tiles or slices.

[0146]

[0170] In step 2720, the device is configured to encode or decode the SPS flag 1110 ("sps_subpic_info_present_flag") in the SPS. The SPS flag 1110 indicates whether subpicture information exists for CLVS referencing the SPS.

[0147]

[0171] In step 2730, the device is configured to determine whether the SPS flag 1110 is equal to 1. Depending on whether the SPS flag 1110 is 0 (step 2730 - no), the device bypasses step 2740 and continues the encoding or decoding process without signaling the SPS syntax element 1112 ("sps_num_subpics_minus1").

[0148]

[0172] Depending on whether the SPS flag 1110 is 1 (step 2730 - Yes), the device is configured to perform step 2740, encoding or decoding the SPS syntax element 1112 ("sps_num_subpics_minus1") in the SPS. The SPS syntax element 1112 ("sps_num_subpics_minus1") is a sequence parameter related to the number of subpictures in each picture in the CLVS referencing the SPS. In particular, (SPS syntax element 1112 + 1) specifies the number of subpictures in each picture in the CLVS. The flowchart as an example shows that step 2740 is performed when the SPS flag 1110 is equal to 1, but it should be understood that the indications of 0 and 1 are design choices, and that the results can be reversed for the SPS flag 1110 and other syntax elements (for example, step 2740 is performed when the SPS flag 1110 is equal to 0).

[0149]

[0173] In step 2750, the device is configured to encode or decode a PPS flag 1210 ("pps_no_pic_partition_flag") in the Picture Parameter Set (PPS) following the SPS, which is equal to an SPS flag 1110 that indicates whether the picture referencing the PPS is partitionable.

[0150]

[0174] The syntax structure 2500 shown in Figure 25 may be applied to method 2700B. Compared with method 2700A, method 2700B is configured such that after step 2170, the device performs step 2715 to determine whether the SPS flag 2410 is equal to 0 (indicating that the picture associated with the SPS is partitionable). If the SPS flag 2410 is 1 (step 2715 - no), indicating that the picture associated with the SPS is not partitionable, the device bypasses step 2720 and skips encoding or decoding the SPS flag 1110. In some embodiments, the value of the SPS flag 1110 may be determined to be 0 when signaling of the SPS flag 1110 is skipped.

[0151]

[0175] The syntax structure 2600 shown in Figure 26 may be applied to method 2700C. Compared with methods 2700A and 2700B, in method 2700C, depending on whether the SPS flag 1110 is equal to 1 (step 2730 - yes), the device is configured to perform step 2715 and determine whether the SPS flag 2410 is equal to 0. Depending on whether the SPS flag 2410 is 1 (step 2715 - no), indicating that the picture associated with the SPS is not partitioned, the device bypasses step 2740 and skips encoding or decoding the SPS syntax element 1112 related to the number of subpictures in each picture in the CLVS that references the SPS. In some embodiments, when the signaling of the SPS syntax element 1112 is skipped, the value of the SPS syntax element 1112 may be determined to be 0.

[0152]

[0176] By method 2700B or 2700C, the SPS flag 1110 ("sps_subpic_info_present_flag") or the SPS syntax element 1112 ("sps_num_subpics_minus1") may be conditionally signaled based on the value of the SPS flag 2410 ("sps_no_pic_partitoin_flag").

[0153]

[0177] Embodiments of this disclosure provide an updated method for signaling flag 1240 ("pps_rect_slice_flag"). Figure 28 shows an exemplary modified coded syntax table of a portion of the PPS syntax structure 2800, including an updated flag indicating a rectangular slice mode or a raster scan slice mode, according to some embodiments of this disclosure. As shown in Figure 28, changes from the previous syntax shown in Figure 12 are indicated by highlighted patterns.

[0154]

[0178] In VVC (e.g., VVC Draft 9), flag 1240 ("pps_rect_slice_flag") is a flag that indicates whether rectangular slice mode or raster scan slice mode is used. As shown in Figure 12, flag 1240 ("pps_rect_slice_flag") may be signaled when the number of tiles is greater than 1. When a picture contains only one tile, a raster scan slice containing only one tile may also be indicated as rectangular slice mode. Therefore, when the number of tiles is equal to 1, there is no need to use raster scan slice mode or signal flag 1240 ("pps_rect_slice_flag"). Thus, signaling of flag 1240 ("pps_rect_slice_flag") is skipped, and the value of flag 1240 is determined to be 1, indicating that rectangular slice mode is applied.

[0155]

[0179] In some cases, when the number of tiles is less than a predetermined value, signaling of flag 1240 is redundant and not essential. When the number of tiles in a picture is less than 4, there is at most one tile column or one tile row in the picture, and therefore the raster scan slice may also be represented as a rectangular slice. Thus, in some embodiments, the slice partitions of a raster scan slice are represented in rectangular slice mode as long as the number of tiles is less than 4. In other words, when the number of tiles is 2 or 3, the partitions may be represented in rectangular slice mode. By adopting this modification, the consistency and efficiency of the encoding and decoding processes for the video stream may be improved.

[0156]

[0180] Therefore, as shown in Figure 28, when the number of tiles is less than 4, the signaling of flag 1240 ("pps_rect_slice_flag") is skipped, and the value of flag 1240 is determined to be 1. When the number of tiles is greater than 3, flag 1240 ("pps_rect_slice_flag") is signaled. In the syntax shown in Figure 28, flag 1240 ("pps_rect_slice_flag") equal to 0 specifies that the raster scan slice mode is used for each picture referencing the PPS (i.e., the tiles in each slice are in raster scan order), and slice information is not signaled in the PPS. Flag 1240 ("pps_rect_slice_flag") equal to 1 specifies that the rectangular slice mode is used for each picture referencing the PPS (i.e., the tiles in each slice cover the rectangular area of ​​the picture), and slice information is signaled in the PPS. Flag 1240 ("pps_rect_slice_flag") is considered equal to 1 if it does not exist. When SPS flag 1110 ("sps_subpic_info_present_flag") is equal to 1, or when PPS flag "pps_mixed_nalu_types_in_pic_flag" is equal to 1, the value of flag 1240 ("pps_rect_slice_flag") is equal to 1.

[0157]

[0181] Figure 29 shows a flowchart of an exemplary video encoding or decoding method 2900, consistent with some embodiments of the present disclosure. Similar to methods 2700A to 2700C, method 2900 may be performed by an encoder or decoder, which may be implemented as one or more software or hardware components of an apparatus (e.g., apparatus 400 in Figure 4) for encoding or transcoding a video sequence or decoding a bitstream to reconstruct a video stream. For example, one or more processors (e.g., processor 402 in Figure 4) may perform method 2900.

[0158]

[0182] The syntax structure 2800 shown in Figure 28 may be applied to method 2900. In step 2910, the device is configured to encode or decode a PPS flag 1210 ("pps_no_pic_partition_flag") for indicating whether a picture referencing a PPS is partitioned in a PPS following an SPS. As described above, in some embodiments, different PPSs may independently signal PPS flags 1210 having different values ​​for pictures within the same CLVS. For example, in step 2910, the device may encode or decode a first flag in a first PPS indicating whether a first picture referencing a first PPS is partitioned into a tile or slice, and a second flag in a second PPS indicating whether a second picture referencing a second PPS is partitioned, in which case the first and second flags have different values. For example, a first flag having a first value may indicate that the first picture in CLVS is not partitioned, while a second flag having a second value different from the first value may indicate that the second picture is partitionable. That is, the second picture in CLVS may be partitionable, but it may also not be partitionable.

[0159]

[0183] In step 2920, the device is configured to determine whether the number of tiles in the picture (e.g., the variable NumTilesInPic) is greater than a threshold (e.g., 3). In some embodiments, the threshold is an integer greater than 1.

[0160]

[0184] Depending on whether the number of tiles in the picture is greater than a threshold (step 2920 - yes), the device performs step 2930 to encode or decode a flag 1240 ("pps_rect_slice_flag") indicating the slice mode applied to the picture. For example, when the raster scan slice mode is applied to a picture referencing a PPS, a flag 1240 ("pps_rect_slice_flag") with a first value (e.g., 0) is encoded or decoded, and when the rectangular slice mode is applied to a picture referencing a PPS, a flag 1240 ("pps_rect_slice_flag") with a second value (e.g., 1) different from the first value is encoded or decoded.

[0161]

[0185] Depending on whether the number of picture tiles is greater than the threshold (step 2920 - no), step 2930 is skipped. In some embodiments, when signaling of flag 1240 ("pps_rect_slice_flag") is skipped, the value of flag 1240 is determined to be a second value (e.g., 1) to indicate that rectangular slice mode is applied.

[0162]

[0186] In step 2940, the device is configured to determine whether rectangular slice mode is applicable according to the value of flag 1240. When rectangular slice mode is applied to a picture referencing a PPS (step 2940 - yes), the device performs step 2950 to encode or decode the slice information in the PPS. When raster scan slice mode is applied to a picture referencing a PPS (step 2940 - no), step 2950 is skipped.

[0163]

[0187] Method 2900 removes constraints so that different PPS associated with pictures within the same CLVS may signal PPS flags 1210 having different values. In addition, the signaling of flag 1240 can be simplified and may be performed conditionally according to the number of tiles. Furthermore, slice information may also be conditionally signaled in the PPS according to the slice mode used for partitioning.

[0164]

[0188] In VVC (e.g., VVC Draft 9), according to the definition of rectangular slice mode, there are two cases in which rectangular slices are supported in VVC. In the first case, a rectangular slice contains several complete tiles that collectively form a rectangular region of a picture. In the second case, a rectangular slice contains several consecutive complete CTU rows of a single tile that collectively form a rectangular region of a picture. However, the semantics of pps_slice_flag specify the first case only when pps_slice_flag is equal to 1. As a result, previous semantics in VVC may be inaccurate.

[0165]

[0189] Embodiments of the present disclosure provide updated semantics for flag 1240 ("pps_rect_slice_flag"). In some embodiments, both cases where a rectangular slice contains one or more complete tiles (e.g., a first slice containing the complete tiles 910 and 920 in Figure 9) and cases where a tile contains one or more slices (e.g., tile 930 containing portions 932 and 934 corresponding to the second and third slices in Figure 9) are specified in the semantics of flag 1240 ("pps_rect_slice_flag") equal to 1. In other words, the semantics for flag 1240 are modified to reflect that flag 1240 ("pps_rect_slice_flag") equal to 1 specifies that the tiles within each slice cover a rectangular area of ​​the picture, "i.e., each slice within the tile covers a rectangular area of ​​the picture," and that slice information is signaled in the PPS.

[0166]

[0190] Alternatively, the semantics for flag 1240 may be modified to reflect that flag 1240 equal to 1 ("pps_rect_slice_flag") specifies that the tiles within each slice cover a rectangular area of ​​the picture, "i.e., each slice within a tile covers one or more consecutive complete CTU rows of the tile," and that slice information is signaled in the PPS.

[0167]

[0191] In some other embodiments, the semantics of flag 1240 ("pps_rect_slice_flag") may directly refer to the raster scan slice mode and the rectangular slice mode. For example, the semantics for flag 1240 may also be modified to reflect that flag 1240 ("pps_rect_slice_flag") equal to 0 specifies that "raster scan slice mode is used for each picture referencing the PPS" and that slice information is not signaled in the PPS, and flag 1240 ("pps_rect_slice_flag") equal to 1 specifies that "rectangular slice mode is used for each picture referencing the PPS" and that slice information is signaled in the PPS.

[0168]

[0192] In VVC (e.g., VVC Draft 9), flag 1250 ("pps_single_slice_per_subpic_flag") specifies whether each subpicture contains one or more rectangular slices. Consequently, flag 1250 is relevant when the rectangular slice mode is applied. When flag 1250 is not present, its value may be determined to be equal to 1. However, as shown in Figure 12, signaling for flag 1250 ("pps_single_slice_per_subpic_flag") may be skipped under two different scenarios. In the first scenario, PPS flag 1210 ("pps_no_pic_partition_flag") is equal to 1, and flags and syntax elements related to slice partitions are skipped. In the second scenario, flag 1240 ("pps_rect_slice_flag") is equal to 0, indicating that raster scan slice mode is applied, and flag 1250 ("pps_single_slice_per_subpic_flag") is irrelevant. Therefore, it is not prudent to determine the value of flag 1250 ("pps_single_slice_per_subpic_flag") under the second scenario.

[0169]

[0193] Therefore, in some embodiments, when it is not present, the value of flag 1250 is determined when rectangular slice mode is applied, but not when raster scan slice mode is applied. Thus, flag 1250 can be properly determined under rectangular slice mode when it is not present in PPS, but not under the unrelated raster scan slice mode. This can improve coding performance and consistency. For example, the semantics for flag 1250 may be modified to reflect that flag 1250 equal to 1 ("pps_single_slice_per_subpic_flag") specifies that each subpicture contains only one rectangular slice. Flag 1250 equal to 0 ("pps_single_slice_per_subpic_flag") specifies that each subpicture may contain one or more rectangular slices. When PPS flag 1210 ("pps_no_pic_partition_flag") is equal to 1, the value of flag 1250 is determined to be equal to 1.

[0170]

[0194] In VVC (e.g., VVC Draft 9), syntax elements 1262 ("pps_slice_width_in_tiles_minus1[i]") and 1264 ("pps_slice_height_in_tiles_minus1[i]") are determined to be equal to 0 when they do not exist. However, in some semantics, the range of index i is not explicitly specified. Furthermore, in some embodiments, syntax elements 1262 and 1264 indicate the width and height of the i-th slice, and therefore the range of index i is from 0 to syntax element 1252 (e.g., number of slices - 1). However, for index i equal to syntax element 1252 ("pps_num_slices_in_pic_minus1"), the values ​​of syntax elements 1262 ("pps_slice_width_in_tiles_minus1[i]") and 1264 ("pps_slice_height_in_tiles_minus1[i]") are not determined to be equal to 0. Therefore, it is desirable to explicitly specify the range of index i for which syntax elements 1262 and 1264 are determined to be equal to 0.

[0171]

[0195] Embodiments of this disclosure provide updated semantics for syntax elements 1262 and 1264. In some embodiments, the semantics for syntax elements 1262 and 1264 may be modified to reflect that syntax element 1262+1 specifies the width of the i-th rectangular slice in a tile column unit, and the value of syntax element 1262 is in the range of 0 or greater and (NumTileColumns-1). The value of syntax element 1262 is determined to be equal to 0 if it does not exist for index i in the range of 0 to (syntax element 1252-1).

[0172]

[0196] Similarly, syntax element 1264+1 specifies the height of the i-th rectangular slice in the tile row unit when syntax element 1266 is equal to 0. The value of syntax element 1264 is in the range of 0 or greater and (NumTileRows-1) or less. If it does not exist for index i in the range of 0 to (syntax element 1252-1), the value of syntax element 1264 is determined to be equal to 0 when SliceTopLeftTileIdx[i] / NumTileColumns is equal to (NumTileRows-1). Otherwise, the value of syntax element 1264 for index i is determined to be equal to the value of syntax element 1264 for index (i-1) ("pps_slice_height_in_tiles_minus1[i-1]").

[0173]

[0197] As shown in Figure 12, in some embodiments, the syntax element 1266 ("pps_num_exp_slices_in_tile[i]") specifies the number of slice heights explicitly given for the slices in the tile containing the i-th slice. If the syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is equal to 0, the tile containing the i-th slice is not divided into multiple slices. If the syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is not equal to 0 (for example, if the syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is greater than 0), the tile containing the i-th slice may or may not be divided into multiple slices. Furthermore, when syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is greater than 0, (syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") + 1) specifies the height of the j-th rectangular slice in the tile containing the i-th slice in the CTU row unit, for index j in the range of 0 or greater and less than or equal to (syntax element 1266 ("pps_num_exp_slices_in_tile[i]") - 1). The value of syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") is in the range of 0 or greater and less than or equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - 1).

[0174]

[0198] In a scenario where a tile contains only one slice, two different signaling methods can apply. In the first method, syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is equal to 0, and the signaling of syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") is skipped. In the second method, syntax 1266 ("pps_num_exp_slices_in_tile[i]") is equal to 1, and pps_exp_slice_height_in_ctus_minus1[i][0] is equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1) (e.g., tile height-1). Both signaling methods indicate that the tile contains only one slice.

[0175]

[0199] In some embodiments, the redundancy in the signaling method described above is eliminated by modifying the syntax elements and their semantics. Embodiments of this disclosure provide updated semantics for the PPS syntax. Figure 30 shows an exemplary modified coded syntax table of a portion of the PPS syntax structure 3000, consistent with some embodiments of this disclosure. As shown in Figure 30, changes from the previous syntax shown in Figure 12 are indicated by highlighted patterns, and proposed deleted syntax is further indicated by strikethrough.

[0176]

[0200] Compared to the SPS syntax shown in Figure 12, in some embodiments, as shown in Figure 30, syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is replaced with syntax element 3066 ("pps_num_exp_slices_in_tile_minus1[i]") (e.g., pps_num_exp_slices_in_tile[i]-1). Thus, the first signaling method is eliminated. When a tile contains one slice, the encoder signals syntax element 3066 ("pps_num_exp_slices_in_tile_minus1[i]") to be equal to 0, and then signals syntax element 1268 (e.g., "pps_exp_slice_height_in_ctus_minus1[i][0]") to be equal to (tile height-1).

[0177]

[0201] In the syntax of Figure 30, (syntax element 3066+1) specifies the number of explicitly given slice heights for slices within the tile containing the i-th slice (i.e., the tile with a tile index equal to SliceTopLeftTileIdx[i]). The value of syntax element 3066 must be between 0 and (the height of the corresponding tile (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns])-2). If the value of syntax element 3066 does not exist, it is considered equal to 0.

[0178]

[0202] In the syntax of Figure 30, (syntax element 1268+1) specifies the height of the j-th rectangular slice in the tile containing the i-th slice in the CTU row unit, for index j in the range of 0 and less than or equal to syntax element 3066 ("pps_num_exp_slices_in_tile_minus1[i]"). The syntax element "pps_exp_slice_height_in_ctus_minus1[i][pps_num_exp_slices_in_tile_minus1[i]]" is also used to derive the height of the rectangular slice in the tile containing the i-th slice having an index greater than syntax element 3066, as specified herein.

[0179]

[0203] Figures 31A and 31B respectively illustrate exemplary detailed operations for encoding or decoding slice information in a PPS in step 2950 of method 2900 of Figure 29, which are consistent with several embodiments of the present disclosure. When the syntax of Figure 12 is applied, step 2950 includes steps 2952 and 2954, as shown in Figure 31A. In step 2952, the device encodes or decodes syntax element 1266 ("pps_num_exp_slices_in_tile[i]") which specifies the number of slice heights explicitly given for slices in the tile containing the i-th slice. In step 2954, the device encodes or decodes syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]"). Syntax element 1268+1 specifies the height of the j-th rectangular slice in the tile containing the i-th slice.

[0180]

[0204] When the modified syntax of Figure 30 is applied, step 2950 includes steps 2956 and 2954, as shown in Figure 31B. In step 2956, the device encodes or decodes the syntax element 3066 ("pps_num_exp_slices_in_tile_minus1[i]"), where (syntax element 3066+1) specifies the number of slice heights explicitly given for slices in the tile containing the i-th slice.

[0181]

[0205] Figure 32 shows a flowchart of an exemplary video encoding or decoding method 3200, consistent with some embodiments of the present disclosure. By applying the video encoding or decoding method 3200, one or more PPS syntax elements or flags may be conditionally signaled based on the values ​​of other syntax elements or flags, thereby reducing the number of output bits and achieving higher encoding performance. When not signaled in PPS, the value of a PPS syntax element or flag may be determined or assigned on a case-by-case basis. Similar to methods 2700A-2700C and 2900, method 3200 may be performed by an encoder or decoder, which may be implemented as one or more software or hardware components of a device (e.g., device 400 in Figure 4) for encoding or transcoding a video sequence or decoding a bitstream to reconstruct a video stream. For example, one or more processors (e.g., processor 402 in Figure 4) may perform method 3200.

[0182]

[0206] In step 3205, the device is configured to encode or decode a PPS flag 1210 ("pps_no_pic_partition_flag") in a PPS to indicate whether a picture referencing the PPS is partitioned. As described above, in some embodiments, different PPSs may independently signal PPS flags 1210 having different values ​​for pictures within the same CLVS. For example, the device may encode or decode a first flag in a first PPS indicating whether a first picture referencing the first PPS is partitioned into a tile or slice, and a second flag in a second PPS indicating whether a second picture referencing the second PPS is partitioned, with the first and second flags having different values.

[0183]

[0207] In step 3210, the device determines whether the picture referencing the PPS is partitioned based on the value of the PPS flag 1210. If the PPS flag 1210 is equal to 1 (step 3210 - yes), the picture referencing the PPS is not partitioned, and the device performs steps 3220 and 3230 to skip encoding or decoding flag 1250 and determine the value of flag 1250 indicating that each subpicture contains a single rectangular slice. For example, in step 3230, flag 1250 may be determined to be 1. If the PPS flag 1210 is equal to 0 (step 3210 - no), the device performs step 3225 to encode or decode flag 1250.

[0184]

[0208] If the value of flag 1250 is determined in step 3230 or step 3225, or if it has been encoded / decoded, then in step 3240, if syntax element 1262 ("pps_slice_width_in_tiles_minus1[i]") is not found in the PPS for index i ranging from 0 to an upper limit equal to (number of rectangular slices in the picture - 2), the device determines that syntax element 1262 is 0. Syntax element 1262 is a picture parameter relating to the width of the i-th rectangular slice for index i. In some embodiments, the value of syntax element 1262 is in the range of 0 or greater and (number of corresponding tile columns (NumTileColumns) - 1).

[0185]

[0209] In step 3250, if the syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") is not found in the PPS for index i ranging from 0 to an upper limit equal to (number of rectangular slices in the picture - 2), the device determines the value of syntax element 1264. Syntax element 1264 is a picture parameter relating to the height of the i-th rectangular slice for index i. In some embodiments, the value of syntax element 1264 is in the range of 0 or greater and (number of rows of corresponding tiles (e.g., NumTileRows) - 1). As described in the embodiments above, if the syntax element 1264 for the i-th rectangular slice does not exist, it may be determined to be 0 or equal to the value of the syntax element 1264 for the (i-1)-th rectangular slice.

[0186]

[0210] In some other embodiments, the semantics for syntax element 1268 may also be modified to reflect that the value of syntax element 1268 is greater than or equal to 0 and less than or equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-2). In other words, syntax element 1268 is a picture parameter to be encoded or decoded, with an upper limit of (height of the corresponding tile-2).

[0187]

[0211] When the maximum value of syntax element 1268 is reduced to (tile height - 2), the second signaling method is removed. Therefore, when the corresponding tile contains a single slice, syntax element 1266 is encoded or decoded to be equal to 0. When the corresponding tile contains two or more slices, syntax element 1266 is encoded or decoded to be 1 or greater.

[0188]

[0212] As described above, in some embodiments, for a rectangular slice in a tile, syntax element 1266 specifies the number of slice heights explicitly given for the slices in the tile containing the i-th slice. When syntax element 1266 is greater than 0, (syntax element 1268+1) specifies the height of the j-th rectangular slice in the tile containing the i-th slice in the CTU row unit for index j in the range of 0 or greater and (syntax element 1266-1). The value of syntax element 1268 is in the range of 0 or greater and (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1).

[0189]

[0213] Note that for each individual slice within a tile, the explicitly signaled slice height is within the range of 0 to the tile height. In addition, assuming that the sum of the heights of all slices within a tile should be equal to the tile height, the sum of the heights of the explicitly signaled slices should be less than or equal to the tile height. When the minimum slice height is equal to 1, (each explicitly signaled slice height - 1) should be less than or equal to (tile height - total number of slices within the tile).

[0190]

[0214] Embodiments of this disclosure provide updated semantics for syntax element 1268. Accordingly, the range of each explicitly signaled slice height may be reduced to a more precise value. In particular, the maximum value of syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") may be changed to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - the number of slice heights explicitly given to slices in the current tile).

[0191]

[0215] When combined with the embodiment shown in Figure 12, the semantics for syntax element 1268 can be modified to reflect that the value of syntax element 1268 is in the range of 0 or greater and less than or equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - value of syntax element 1266). In other words, the upper limit of syntax element 1268 is (height of the corresponding tile - number of slice heights explicitly given for slices within the corresponding tile).

[0192]

[0216] When combined with the embodiment shown in Figure 30, which replaces syntax element 1266 with syntax element 3066, the semantics for syntax element 1268 can be modified to reflect that the value of syntax element 1268 is in the range of 0 or greater and (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-value of syntax element 3066-1).

[0193]

[0217] In combination with an embodiment that reduces the maximum value of syntax element 1268 to (tile height - 2), a function max(pps_num_exp_slices_in_tile[i],2) may be used, which selects the larger of syntax element 1266 ("pps_num_exp_slices_in_tile[i]") and 2, and the semantics for syntax element 1268 may be further modified to reflect that the value of syntax element 1268 is greater than or equal to 0 and less than or equal to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-max(pps_num_exp_slices_in_tile[i],2)). In other words, the upper limit for syntax element 1268 is the smaller of (the height of the corresponding tile (e.g., RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns])-2) and (the height of the corresponding tile - the number of slice heights explicitly given in the corresponding tile (pps_num_exp_slices_in_tile[i])).

[0194]

[0218] Figure 33 shows exemplary pseudocode relating to several embodiments of the present disclosure, including updated derivations of the variables NumCtusInSlice, SliceTopLeftTileIdx, CtbAddrInSlice, and NumSlicesInTile. As shown in Figure 33, changes from previous VVCs are indicated by highlighted patterns, and proposed deleted syntax is further indicated by strikethrough.

[0195]

[0219] Figure 34 shows exemplary pseudocode, including updated derivations of the variables NumCtusInSlice and CtbAddrInSlice, relating to several embodiments of the present disclosure. As shown in Figure 34, changes from the previous VVC are indicated in italics, and proposed deleted syntax is indicated in strikethrough. The pseudocode shown in Figure 34 corrects errors and one redundant line in the derivation of NumCtusInSlice[i] and CtbAddrInSlice[i][j] in the previous VVC pseudocode.

[0196]

[0220] Considering the above, the encoding / decoding method can be consistent and efficient by modifying the SPS and PPS syntax elements related to the tile / slice partitions, as proposed in various embodiments of this disclosure. In addition, by appropriately determining the value of the syntax elements when they are not signaled, the signaling of some syntax elements related to the tile / slice partitions may be skipped in some cases, thereby reducing the number of output bits and thus improving encoding efficiency.

[0197]

[0221] While various embodiments of this disclosure are described in relation to the current VVC standard, it should be understood that these embodiments are applicable to other video encoding technologies.

[0198]

[0222] Embodiments can be further described using the following clauses. 1. A method for encoding or decoding video, The process includes encoding or decoding a corresponding first PPS flag in a set of multiple picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), which indicates whether the picture can be partitioned into multiple tiles or slices. A method comprising: in a first PPS, a corresponding first PPS flag having a first value indicates that the first picture in the CLVS is not partitioned; and in a second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture in the CLVS is partitionable. 2. A method for encoding or decoding video, This involves determining whether the number of tiles in a partitioned picture is greater than a threshold, and that the threshold is greater than 1. Depending on whether the number of tiles in the partitioned picture is greater than a threshold, a second PPS flag associated with the slice mode applied to the partitioned picture is encoded or decoded, Methods that include... 3. Encoding or decoding the second PPS flag is The method according to Clause 1 or Clause 2, including encoding or decoding a second PPS flag having a third value when a raster scan slice mode is applied to a partitioned picture that references a PPS, or encoding or decoding a second PPS flag having a fourth value different from the third value when a rectangular slice mode is applied to a partitioned picture that references a PPS. 4. The method according to Clause 3, further comprising encoding or decoding one or more syntax elements that specify slice information in a PPS when rectangular slice mode is applied to a partitioned picture that references a PPS. 5. A method for encoding or decoding video, Determining whether the picture is divided into multiple tiles or slices, In response to a determination that a picture can be partitioned into multiple tiles or slices, the process includes encoding or decoding a first flag in the Picture Parameter Set (PPS) associated with the slice mode applied to the picture referencing the PPS, A method for encoding or decoding a first flag having a first value when a raster scan slice mode is applied to partition a picture, or encoding or decoding a first flag having a second value different from the first value when a rectangular slice mode is applied to partition a picture. 6. In raster scan slice mode, a picture is divided into multiple raster scan slices, and each raster scan slice contains one or more complete tile sequences in the tile raster scan of the picture. The method according to any one of the clauses 3 to 5, wherein, in rectangular slice mode, the picture is divided into multiple rectangular slices, one of which contains one or more tiles that cover a rectangular area of ​​the picture, or one of which covers one or more consecutive rows of coded tree units of a tile. 7. The method according to clause 5 or 6, further comprising encoding or decoding a first picture parameter specifying (the number of slice heights given for the slices in the corresponding tile - 1), wherein if the corresponding tile contains a single slice, the first picture parameter is equal to 0. 8. The value of the first picture parameter is in the range of 0 or greater and (height of the corresponding tile - 2) or less, as described in Clause 7. 9. The method according to any of the clauses 5 to 8, further comprising encoding or decoding a third picture parameter that specifies the number of slice heights given for a slice in a corresponding tile, wherein the third picture parameter is equal to 0 if the corresponding tile contains a single slice. 10. The method according to Clause 9, further comprising encoding or decoding a second picture parameter specifying (height of the corresponding rectangular slice in the corresponding tile - 1). 11. The method according to clause 10, wherein the upper limit of the second picture parameter is (height of the corresponding tile - 2). 12. The method according to clause 10, wherein the upper limit of the second picture parameter is (height of the corresponding tile - fourth picture parameter), and the fourth picture parameter indicates the number of slice heights given for the slices in the corresponding tile. 13. The upper limit of the second picture parameter is (height of the corresponding tile - fifth parameter - 1), The method according to clause 10, wherein the fifth picture parameter is (the number of slice heights given for the slices in the corresponding tile - 1). 14. The method according to clause 10, wherein the upper limit of the second picture parameter is the smaller of (height of the corresponding tile - 2) and (height of the corresponding tile - number of slice heights given in the corresponding tile). 15. A method for encoding or decoding video, Encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture in a coded layer video sequence (CLVS), wherein a first PPS flag equal to a first value indicates that the associated picture is not partitionable, and a first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable. When the first PPS flag is equal to the first value, skip encoding or decoding the second PPS flag in the PPS, which indicates whether each sub-picture of the associated picture contains a single rectangular slice, and determine the value of the second PPS flag equal to the third value, wherein the second PPS flag equal to the third value indicates that each sub-picture of the associated picture contains a single rectangular slice. Methods that include... 16. A method for encoding or decoding video, For index i, the first picture parameter associated with the width of the i-th rectangular slice in the picture parameter set (PPS) associated with at least one picture in the coded layer video sequence (CLVS), This includes determining that the first picture parameter is 0 when the first picture parameter does not exist in the PPS, The method where index i is in the range from 0 to an upper limit equal to (number of rectangular slices in the picture - 2). 17. For index i, the second picture parameter associated with the height of the i-th rectangular slice is encoded or decoded, When the second picture parameter does not exist in PPS for index i, determine that the second picture parameter is either 0 or equal to the value of the third picture parameter associated with the height of the (i-1)th rectangular slice, The method described in Article 16, further including the method described in Article 16. 18. A method for encoding or decoding video, In a bitstream sequence parameter set (SPS), encoding or decoding a first SPS flag indicating whether one or more pictures in a coded layer video sequence (CLVS) referencing the SPS are partitioned into multiple tiles or slices, In the Picture Parameter Set (PPS) associated with the SPS, a first PPS flag equal to a first SPS flag indicating whether a picture referencing the PPS is partitioned, Methods that include... 19. The method according to Clause 18, wherein, in response to a first SPS flag indicating that one or more pictures are not partitioned, the encoding or decoding of a second SPS flag in the SPS is skipped, and the second SPS flag further comprises indicating whether subpicture information exists for a CLVS referring to the SPS. 20. The method according to clause 18 or clause 19, further comprising skipping the encoding or decoding of a first SPS sequence parameter associated with the number of subpictures in each picture in the CLVS referencing the SPS, in response to a first SPS flag indicating that one or more pictures are not partitioned. 21. Apparatus, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with Encoding or decoding a corresponding first PPS flag in multiple picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), which indicates whether the picture can be partitioned into multiple tiles or slices. It is configured to execute commands in order to perform the following: A device in which, in a first PPS, a corresponding first PPS flag having a first value indicates that the first picture of the CLVS is not partitioned, and in a second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture of the CLVS is partitionable. 22. Apparatus, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with This involves determining whether the number of tiles in a partitioned picture is greater than a threshold, and that the threshold is greater than 1. Depending on whether the number of tiles in a partitioned picture is greater than a threshold, encode or decode a second PPS flag associated with the slice mode applied to the partitioned picture. A device configured to execute commands in order to perform an action. 23. One or more processors in the device When raster scan slice mode is applied to a partitioned picture referencing PPS, encode or decode a second PPS flag having a third value, or when rectangular slice mode is applied to a partitioned picture referencing PPS, encode or decode a second PPS flag having a fourth value different from the third value. The apparatus described in Clause 21 or Clause 22, configured to execute instructions in order to encode or decode a second PPS flag. 24. One or more processors further in the device When rectangular slice mode is applied to a partitioned picture that references a PPS, one or more syntax elements that specify slice information in the PPS are encoded or decoded. The apparatus described in Clause 23, configured to execute instructions in order to perform the following. 25. Apparatus, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with Determining whether the picture is divided into multiple tiles or slices, In response to the determination that a picture can be partitioned into multiple tiles or slices, a first flag associated with the slice mode applied to the picture referencing the Picture Parameter Set (PPS) is encoded or decoded in the PPS. When raster scan slice mode is applied to partition a picture, a first flag having a first value is encoded or decoded, or when rectangular slice mode is applied to partition a picture, a first flag having a second value different from the first value is encoded or decoded. A device configured to execute commands in order to perform an action. 26. In raster scan slice mode, the picture is divided into multiple raster scan slices, and any of the raster scan slices contains one or more complete tile sequences in the tile raster scan of the picture. The apparatus according to Clause 25, wherein, in rectangular slice mode, a picture is partitioned into a plurality of rectangular slices, one of which contains one or more tiles covering a rectangular area of ​​the picture, or one of which covers one or more consecutive rows of coded tree units of tiles. 27. One or more processors further to the device Encoding or decoding a first picture parameter that specifies (the number of slice heights given for the slices in the corresponding tile - 1) The apparatus according to Clause 25 or Clause 26, configured to execute an instruction in order to perform the following: if the corresponding tile contains a single slice, the first picture parameter is equal to 0. 28. The device described in Clause 27, wherein the value of the first picture parameter is in the range of 0 or greater and (height of the corresponding tile - 2) or less. 29. One or more processors further to the device Encoding or decoding a third picture parameter that specifies the number of slice heights given for slices within the corresponding tile. The apparatus described in any of clauses 25-28, configured to execute instructions in order to perform the following: if the corresponding tile contains a single slice, the third picture parameter is equal to 0. 30. One or more processors are provided to the device, Encode or decode a second picture parameter specifying (height of the corresponding rectangular slice within the corresponding tile - 1). The apparatus described in Clause 29, configured to execute instructions in order to perform the following actions. 31. The apparatus described in Clause 30, wherein the upper limit of the second picture parameter is (height of the corresponding tile - 2). 32. The apparatus according to Clause 30, wherein the upper limit of the second picture parameter is (height of the corresponding tile - fourth picture parameter), and the fourth picture parameter indicates the number of slice heights given for slices within the corresponding tile. 33. The upper limit of the second picture parameter is (height of the corresponding tile - fifth parameter - 1), The apparatus according to Clause 30, wherein the fifth picture parameter is (the number of slice heights given for the slices in the corresponding tile - 1). 34. The apparatus according to Clause 30, wherein the upper limit of the second picture parameter is the smaller of (height of the corresponding tile - 2) and (height of the corresponding tile - the number of slice heights given in the corresponding tile). 35. Apparatus, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with Encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture in a coded layer video sequence (CLVS), wherein the first PPS flag equal to a first value indicates that the associated picture is not partitionable, or the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable. When the first PPS flag is equal to the first value, the PPS skips encoding or decoding the second PPS flag, which indicates whether each sub-picture of the associated picture contains a single rectangular slice, and determines the value of the second PPS flag equal to the third value, wherein the second PPS flag equal to the third value indicates that each sub-picture of the associated picture contains a single rectangular slice. A device configured to execute commands in order to perform an action. 36. Apparatus, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with For index i, the first picture parameter associated with the width of the i-th rectangle in the picture parameter set (PPS) associated with at least one picture in the coded layer video sequence (CLVS), When the first picture parameter does not exist in the PPS, it is determined that the first picture parameter is 0, A device configured to execute instructions in order to perform the following: an index i is in the range of 0 to an upper limit equal to (number of rectangular slices in the picture - 2). 37. One or more processors further in the device For index i, the second picture parameter associated with the height of the i-th rectangular slice is encoded or decoded, When the second picture parameter does not exist in PPS for index i, determine that the second picture parameter is either 0 or equal to the value of the third picture parameter associated with the height of the (i-1)th rectangular slice, The apparatus described in Clause 36, configured to execute instructions in order to perform the following actions. 38. A device, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors provide the device with In a bitstream sequence parameter set (SPS), encoding or decoding a first SPS flag indicating whether one or more pictures in a coded layer video sequence (CLVS) referencing the SPS are partitioned into multiple tiles or slices, In the Picture Parameter Set (PPS) associated with the SPS, a first PPS flag equal to a first SPS flag indicating whether the picture referencing the PPS is partitioned is encoded or decoded. A device configured to execute commands in order to perform an action. 39. One or more processors further in the device The first SPS flag indicates that one or more pictures are not partitioned, and in that case, the encoding or decoding of the second SPS flag within the SPS is skipped. The apparatus described in Clause 38, configured to execute an instruction in order to perform the following: a second SPS flag indicating whether subpicture information exists for a CLVS that references an SPS. 40. One or more processors are added to the device. Depending on whether the first SPS flag indicates that one or more pictures are not partitioned, skip encoding or decoding the first SPS sequence parameter associated with the number of subpictures within each picture in the CLVS referencing the SPS. The apparatus described in Clause 38 or Clause 39, configured to execute an instruction in order to perform the following. 41. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: The process includes encoding or decoding a corresponding first PPS flag in a set of multiple picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), which indicates whether the picture can be partitioned into multiple tiles or slices. A non-temporary computer-readable storage medium in which, in a first PPS, a corresponding first PPS flag having a first value indicates that the first picture of the CLVS is not partitioned, and in a second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture of the CLVS is partitionable. 42. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: This involves determining whether the number of tiles in a partitioned picture is greater than a threshold, and that the threshold is greater than 1. Depending on whether the number of tiles in the partitioned picture is greater than a threshold, a second PPS flag associated with the slice mode applied to the partitioned picture is encoded or decoded, Non-temporary computer-readable storage media, including [specific type of storage medium]. 43. A set of instructions that can be executed by one or more processors of a device, When raster scan slice mode is applied to a partitioned picture that references PPS, encode or decode a second PPS flag having a third value, or when rectangular slice mode is applied to a partitioned picture that references PPS, encode or decode a second PPS flag having a fourth value different from the third value. A non-temporary computer-readable storage medium as described in Clause 41 or Clause 42, which causes the device to further perform the encoding or decoding of a second PPS flag. 44. The set of instructions is When rectangular slice mode is applied to a partitioned picture that references a PPS, one or more syntax elements that specify slice information in the PPS are encoded or decoded. A non-temporary computer-readable storage medium as described in Clause 43, which is executable by one or more processors of the device in order to cause the device to perform further operations including the above. 45. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: Determining whether the picture is divided into multiple tiles or slices, In response to a determination that a picture can be partitioned into multiple tiles or slices, the process includes encoding or decoding a first flag in the Picture Parameter Set (PPS) associated with the slice mode applied to the picture referencing the PPS, A non-temporary computer-readable storage medium that encodes or decodes a first flag having a first value when a raster scan slice mode is applied to partition a picture, or encodes or decodes a first flag having a second value different from the first value when a rectangular slice mode is applied to partition a picture. 46. In raster scan slice mode, a picture is divided into multiple raster scan slices, and each raster scan slice contains one or more complete tile sequences in the tile raster scan of the picture. A non-temporary computer-readable storage medium as described in Clause 45, wherein in rectangular slice mode, the picture is partitioned into a plurality of rectangular slices, one of which contains one or more tiles covering a rectangular area of ​​the picture, or one of which covers one or more consecutive rows of coded tree units of the tiles. 47. A set of instructions that can be executed by one or more processors of a device, Encoding or decoding a first picture parameter that specifies (the number of slice heights given for the slices in the corresponding tile - 1), wherein the first picture parameter is equal to 0 if the corresponding tile contains a single slice. A non-temporary computer-readable storage medium as described in Clause 45 or Clause 46, which causes the device to perform further operations including those described above. 48. The value of the first picture parameter is in the range of 0 or greater and (height of the corresponding tile - 2) or less, for a non-temporary computer-readable storage medium as described in Clause 47. 49. A set of instructions that can be executed by one or more processors of a device, Encoding or decoding a third picture parameter that specifies the number of given slice heights for slices within a corresponding tile, wherein the third picture parameter is equal to 0 if the corresponding tile contains a single slice. A non-temporary computer-readable storage medium as described in any of clauses 45-48, which causes the device to perform further operations including those described above. 50. A set of instructions that can be executed by one or more processors of a device, Encode or decode a second picture parameter specifying (height of the corresponding rectangular slice within the corresponding tile - 1). A non-temporary computer-readable storage medium as described in Clause 49, which causes the device to perform further operations including those described above. 51. A non-temporary computer-readable storage medium as described in Clause 50, wherein the upper limit of the second picture parameter is (height of the corresponding tile - 2). 52. A non-temporary computer-readable storage medium as described in Clause 50, wherein the upper limit of the second picture parameter is (height of the corresponding tile - fourth picture parameter), and the fourth picture parameter indicates the number of slice heights given for the slices in the corresponding tile. 53. The upper limit of the second picture parameter is (height of the corresponding tile - fifth parameter - 1), A non-temporary computer-readable storage medium as described in Clause 50, wherein the fifth picture parameter indicates (the number of slice heights given for the slices in the corresponding tile - 1). 54. A non-temporary computer-readable storage medium as described in Clause 50, wherein the upper limit of the second picture parameter is the smaller of (height of the corresponding tile - 2) and (height of the corresponding tile - the number of slice heights given in the corresponding tile). 55. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: Encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture in a coded layer video sequence (CLVS), wherein the first PPS flag equal to a first value indicates that the associated picture is not partitionable, or the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable. When the first PPS flag is equal to the first value, the PPS skips encoding or decoding the second PPS flag, which indicates whether each sub-picture of the associated picture contains a single rectangular slice, and determines the value of the second PPS flag equal to the third value, wherein the second PPS flag equal to the third value indicates that each sub-picture of the associated picture contains a single rectangular slice. Non-temporary computer-readable storage media, including [specific type of storage medium]. 56. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: For index i, the first picture parameter associated with the width of the i-th rectangular slice in the picture parameter set (PPS) associated with at least one picture in the coded layer video sequence (CLVS), This includes determining that the first picture parameter is 0 when the first picture parameter does not exist in the PPS, A non-temporary computer-readable storage medium in which index i is in the range from 0 to an upper limit equal to (number of rectangular slices in the picture - 2). 57. A set of instructions that can be executed by one or more processors of a device, For index i, the second picture parameter associated with the height of the i-th rectangular slice is encoded or decoded, When the second picture parameter does not exist in PPS for index i, determine that the second picture parameter is either 0 or equal to the value of the third picture parameter associated with the height of the (i-1)th rectangular slice, A non-temporary computer-readable storage medium as described in Clause 56, which causes the device to perform further operations including those described above. 58. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of the device in order to cause the device to perform an operation, and the operation is: In a bitstream sequence parameter set (SPS), encoding or decoding a first SPS flag indicating whether one or more pictures in a coded layer video sequence (CLVS) referencing the SPS are partitioned into multiple tiles or slices, In the Picture Parameter Set (PPS) associated with the SPS, a first PPS flag equal to a first SPS flag indicating whether a picture referencing the PPS is partitioned, Non-temporary computer-readable storage media, including [specific type of storage medium]. 59. A set of instructions that can be executed by one or more processors of a device, The first SPS flag indicates that one or more pictures are not partitioned, and the encoding or decoding of the second SPS flag in the SPS is skipped, wherein the second SPS flag indicates whether subpicture information exists for the CLVS referencing the SPS. A non-temporary computer-readable storage medium as described in Clause 58, which causes the device to perform further operations including those described above. 60. A set of instructions that can be executed by one or more processors of a device, Depending on whether the first SPS flag indicates that one or more pictures are not partitioned, skip encoding or decoding the first SPS sequence parameter associated with the number of subpictures within each picture in the CLVS referencing the SPS. The non - transient computer - readable storage medium according to clause 58 or clause 59, which further causes the device to perform an operation including this.

[0199]

[0223] In some embodiments, a non - transient computer - readable storage medium including instructions is also provided, and the instructions can be executed by a device (such as an encoder and a decoder disclosed) for performing the above - mentioned method. Common non - transient media include, for example, floppy (registered trademark) 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 medium having a pattern of holes, RAM, PROM, and EPROM, FLASH (registered trademark) - EPROM or any other flash memory, NVRAM, cache, registers, any other memory chips or cartridges, and networked versions of these. The device may include one or more processors (CPUs), an input / output interface, a network interface, and / or memory.

[0200]

[0224] It should be noted that relative terms such as "first" and "second" in this specification are only used to distinguish one entity or operation from another entity or operation, and do not require or imply any actual relationship or order between those entities or operations. Further, "comprising", "having", "containing", "including" and other similar forms of terms are intended to be equivalent in meaning, and are not intended to be an exhaustive listing of items following any one of these terms, or to be limited only to the items listed, and are intended to be non - limiting in that regard.

[0201]

[0225] 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, B, 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, B, C, A and B, A and C, B and C, A and B and C.

[0202]

[0226] 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.

[0203]

[0227] 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 putting into practice the disclosures 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 the steps may be performed in different orders while implementing the same method.

[0204]

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

Claims

1. A method for encoding or decoding video, The process includes encoding or decoding a corresponding first PPS flag in a set of multiple picture parameter sets (PPS) associated with a picture in a coded layer video sequence (CLVS), which indicates whether the picture can be partitioned into multiple tiles or slices. A method comprising: in a first PPS, a corresponding first PPS flag having a first value indicates that the first picture of the CLVS is not partitioned; and in a second PPS, another corresponding first PPS flag having a second value different from the first value indicates that the second picture of the CLVS is partitionable.

2. Determining whether the number of tiles in a partitioned picture is greater than a threshold, and that the threshold is greater than 1, Depending on whether the number of tiles in the partitioned picture is greater than the threshold, a second PPS flag associated with the slice mode applied to the partitioned picture is encoded or decoded. The method according to claim 1, further comprising:

3. The encoding or decoding of the second PPS flag is performed as follows: The method according to claim 2, comprising: when a raster scan slice mode is applied to the partitioned picture that references the PPS, encoding or decoding the second PPS flag having a third value; or when a rectangular slice mode is applied to the partitioned picture that references the PPS, encoding or decoding the second PPS flag having a fourth value different from the third value.

4. The method according to claim 3, further comprising encoding or decoding one or more syntax elements that specify slice information in the PPS when the rectangular slice mode is applied to the partitioned picture that references the PPS.

5. It is a device, Memory configured to store instructions, The device comprises one or more processors, and the one or more processors are provided to the device. Determining whether the picture is divided into multiple tiles or slices, In response to the determination that the picture can be partitioned into the plurality of tiles or slices, a first flag associated with the slice mode applied to the picture that references the PPS is encoded or decoded in the picture parameter set (PPS), When a raster scan slice mode is applied to partition the picture, the first flag having a first value is encoded or decoded, or when a rectangular slice mode is applied to partition the picture, the first flag having a second value different from the first value is encoded or decoded. A device configured to execute the aforementioned command in order to perform the following.

6. In the raster scan slice mode, the picture is divided into a plurality of raster scan slices, and any of the raster scan slices includes one or more complete tile sequences in the tile raster scan of the picture. The apparatus according to claim 5, wherein, in the rectangular slice mode, the picture is divided into a plurality of rectangular slices, one of the rectangular slices includes one or more tiles that cover a rectangular area of ​​the picture, or one of the rectangular slices covers one or more consecutive rows of coded tree units of the tiles.

7. The one or more processors further in the device Encode or decode a first picture parameter that specifies (the number of slice heights given for the slices in the corresponding tile - 1). The apparatus according to claim 5, configured to execute the instruction in order to perform the action, wherein the first picture parameter is equal to 0 if the corresponding tile includes a single slice.

8. The apparatus according to claim 7, wherein the value of the first picture parameter is in the range of 0 or greater and (height of the corresponding tile - 2) or less.

9. The one or more processors further in the device Encoding or decoding a third picture parameter that specifies the number of given slice heights for slices within a corresponding tile. The apparatus according to claim 5, configured to execute the instruction in order to perform the action, wherein the third picture parameter is equal to 0 if the corresponding tile includes a single slice.

10. The one or more processors further in the device Encoding or decoding a second picture parameter that specifies (height of the corresponding rectangular slice within the corresponding tile - 1) The apparatus according to claim 9, configured to execute the command in order to perform the above.

11. The apparatus according to claim 10, wherein the upper limit of the second picture parameter is (the height of the corresponding tile minus 2).

12. The apparatus according to claim 10, wherein the upper limit of the second picture parameter is (the height of the corresponding tile - the fourth picture parameter), and the fourth picture parameter indicates the number of slice heights given to the slices in the corresponding tile.

13. The upper limit of the second picture parameter is (the height of the corresponding tile - the fifth parameter - 1), The apparatus according to claim 10, wherein the fifth picture parameter is (the number of slice heights given for the slices in the corresponding tile minus 1).

14. The apparatus according to claim 10, wherein the upper limit of the second picture parameter is the smaller of (the height of the corresponding tile - 2) and (the height of the corresponding tile - the number of slice heights given in the corresponding tile).

15. A non-temporary computer-readable storage medium for storing a set of instructions, wherein the set of instructions is executable by one or more processors of a device to cause the device to perform an operation, and the operation is, Encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture in a coded layer video sequence (CLVS), wherein the first PPS flag equal to a first value indicates that the associated picture is not partitionable, or the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable. When the first PPS flag is equal to the first value, the PPS skips encoding or decoding a second PPS flag indicating whether each sub-picture of the associated picture contains a single rectangular slice, and determines the value of the second PPS flag equal to the third value, wherein the second PPS flag equal to the third value indicates that each sub-picture of the associated picture contains a single rectangular slice. Non-temporary computer-readable storage media, including [specific type of storage medium].

16. The aforementioned set of instructions For index i, the first picture parameter associated with the width of the i-th rectangular slice in the picture parameter set (PPS) associated with at least one picture in the coded layer video sequence (CLVS), When the first picture parameter does not exist in the PPS, it is determined that the first picture parameter is 0, To cause the device to perform further operations including the above, the above can be performed by one or more processors of the device. The non-temporary computer-readable storage medium according to claim 15, wherein the index i is in the range of 0 to an upper limit equal to (the number of rectangular slices in the picture - 2).

17. The aforementioned set of instructions For the index i, the second picture parameter associated with the height of the i-th rectangular slice is encoded or decoded. When the second picture parameter does not exist in the PPS for the index i, it is determined that the second picture parameter is either 0 or equal to the value of the third picture parameter associated with the height of the (i-1)th rectangular slice, A non-temporary computer-readable storage medium according to claim 16, which is executable by one or more processors of the device to cause the device to perform further operations including the above.

18. The aforementioned set of instructions In a bitstream sequence parameter set (SPS), encoding or decoding a first SPS flag indicating whether one or more pictures in the CLVS referencing the SPS are partitioned into the plurality of tiles or slices, Encoding or decoding a first PPS flag that is equal to the first SPS flag for indicating whether the picture referencing the PPS is partitioned, in the PPS associated with the SPS, A non-temporary computer-readable storage medium according to claim 15, which is executable by one or more processors of the device to cause the device to perform operations including the above.

19. The aforementioned set of instructions In response to the first SPS flag indicating that the one or more pictures are not partitioned, skip encoding or decoding the second SPS flag within the SPS. The non-temporary computer-readable storage medium according to claim 18, which is executable by one or more processors of the device to cause the device to perform further operations including the above, wherein the second SPS flag indicates whether subpicture information exists for the CLVS that references the SPS.

20. The aforementioned set of instructions In response to the first SPS flag indicating that the one or more pictures are not partitioned, skip encoding or decoding the first SPS sequence parameter associated with the number of subpictures in each picture in the CLVS referencing the SPS. A non-temporary computer-readable storage medium according to claim 18, which is executable by one or more processors of the device to cause the device to perform operations including the above.

Images