Tile and slice partitioning in video processing

Abstract

To provide a computer-implemented method for encoding or decoding a video.SOLUTION: The method includes encoding or decoding, in a plurality of picture parameter sets (PPS) associated with pictures of a coded layer video sequence (CLVS), corresponding first PPS flags indicating whether pictures are allowed to be partitioned into a plurality of tiles or slices. In a first PPS, a corresponding first PPS flag with a first value indicates that a first picture of the CLVS is unpartitioned; and, in a second PPS, another corresponding first PPS flag with a second value different from the first value indicates that a second picture of the CLVS is allowed to be partitioned.SELECTED DRAWING: Figure 1

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 May 21, 2020, which provisional application is incorporated by reference in its entirety herein.

[0002] Technical Field

[0002] The present disclosure relates generally to video data processing, and more particularly to picture partitioning. [Background technology]

[0003] background

[0003] A video is a set of static pictures (or "frames") that capture visual information. To reduce storage memory and transmission bandwidth, a 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. There are various video coding formats that use standardized video coding techniques, most commonly based on prediction, transformation, quantization, entropy coding, and in-loop filtering. Video coding standards, such as the High Efficiency Video Coding (HEVC / H.265) standard, the Versatile Video Coding (VVC / H.266) standard, and the AVS standard, that specify specific video coding formats, are developed by standardization organizations. As more advanced video coding techniques are adopted into video standards, the coding efficiency of the new video coding standards becomes higher. Summary of the Invention [Means for solving the problem]

[0004] Disclosure Summary

[0004] An embodiment of the present disclosure provides a method for encoding or decoding video. The method includes encoding or decoding corresponding first PPS flags in multiple Picture Parameter Sets (PPS) associated with a picture of a Coded Layer Video Sequence (CLVS), the first PPS flag indicating whether the picture can be partitioned into multiple tiles or slices. In the first PPS, a corresponding first PPS flag having a first value indicates that the first picture of the CLVS is not partitioned, and in the 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.

[0005]

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

[0006]

[0006] In some embodiments, a method for decoding a video includes encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture of a coded layer video sequence (CLVS), the first PPS flag indicating whether the associated picture can be partitioned into multiple tiles or slices, where the first PPS flag equal to a first value indicates that the associated picture is not partitioned 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, skipping encoding or decoding a second PPS flag in the PPS indicating whether each sub-picture of the associated picture includes a single rectangular slice; and determining a value of the second PPS flag equal to a third value, where the second PPS flag equal to the third value indicates that each sub-picture of the associated picture includes a single rectangular slice.

[0007]

[0007] An embodiment of the present disclosure provides an apparatus including a memory configured to store instructions and one or more processors, the one or more processors configured to execute the instructions to cause the apparatus to perform any of the above methods.

[0008]

[0008] An embodiment of the present disclosure provides a non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations for any of the above methods.

[0009] BRIEF DESCRIPTION OF THE DRAWINGS

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

[0010] [Figure 1]

[0010] FIG. 1 is a schematic diagram illustrating an example structure of a video sequence consistent with some embodiments of the present disclosure. [Figure 2A]

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

[0012] 1 is a schematic diagram illustrating another exemplary encoding process of a hybrid video coding system consistent with embodiments of the present disclosure. [Figure 3A]

[0013] 1 is a schematic diagram illustrating an example decoding process for a hybrid video coding system consistent with embodiments of the present disclosure. [Figure 3B]

[0014] 1 is a schematic diagram illustrating another example decoding process for a hybrid video coding system consistent with embodiments of the present disclosure. [Figure 4]

[0015] 1 is a block diagram of an example device for encoding or decoding video consistent with certain embodiments of the present disclosure. [Diagram 5]

[0016] 1 is a schematic diagram of an example bitstream consistent with certain embodiments of the present disclosure. [Figure 6]

[0017] FIG. 2 is a schematic diagram illustrating a structure of a picture partitioned into blocks, consistent with some embodiments of the present disclosure. [Figure 7]

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

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

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

[0021] FIG. 2 is a schematic diagram illustrating the structure of a picture partitioned in rectangular slice mode, consistent with some embodiments of the present disclosure. [Figure 11]

[0022] 1 illustrates an example coding syntax table of a portion of an SPS syntax structure, consistent with certain embodiments of the present disclosure. [Figure 12A]

[0023] 1 illustrates an example coding syntax table of a portion of a PPS syntax structure, consistent with certain embodiments of the present disclosure. [Figure 12B] 1 illustrates an example coding syntax table of a portion of a PPS syntax structure consistent with certain embodiments of the present disclosure. [Figure 13]

[0024] 1 shows exemplary pseudocode consistent with certain embodiments of the present disclosure. [Figure 14]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 15]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 16]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 17]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 18]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 19]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 20]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 21A]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 21B]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Figure 22]

[0024] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. [Diagram 23]

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

[0025] 1 illustrates an example coding syntax table of a portion of an SPS syntax structure, consistent with certain embodiments of the present disclosure. [Diagram 25]

[0026] 13 shows another example coding syntax table of a portion of an SPS syntax structure, consistent with certain embodiments of the present disclosure. [Figure 26]

[0027] 13 shows another example coding syntax table of a portion of an SPS syntax structure, consistent with certain embodiments of the present disclosure. [Figure 27A]

[0028] 1 shows a flowchart of an example video encoding or decoding method consistent with certain embodiments of this disclosure. [Figure 27B] 1 shows a flowchart of an example video encoding or decoding method consistent with certain embodiments of this disclosure. [Figure 27C] 1 shows a flowchart of an example video encoding or decoding method consistent with certain embodiments of this disclosure. [Figure 28]

[0029] 1 illustrates an example modified coding syntax table of a portion of a PPS syntax structure consistent with certain embodiments of the present disclosure. [Figure 29]

[0030] 1 shows a flowchart of an example video encoding or decoding method consistent with certain embodiments of this disclosure. [Diagram 30]

[0031] 1 illustrates an example modified coding syntax table of a portion of a PPS syntax structure consistent with certain embodiments of the present disclosure. [Figure 31A]

[0032] 30 illustrates exemplary operational details of steps of the method of FIG. 29 consistent with certain embodiments of the present disclosure. [Figure 31B]

[0032] Exemplary detailed operations of steps of the method of FIG. 29 are shown consistent with certain embodiments of the present disclosure. [Diagram 32]

[0033] 1 shows a flowchart of an example video encoding or decoding method consistent with certain embodiments of this disclosure. [Diagram 33]

[0034] 1 shows exemplary pseudocode consistent with certain embodiments of the present disclosure. [Figure 34A]

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

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

[0034] Exemplary pseudocode consistent with certain embodiments of the present disclosure is provided below. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0011] Detailed Description

[0035] Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. The following description refers to the accompanying drawings, in which the same numerals in different figures represent the same or similar elements unless otherwise indicated. The implementations described in the following description of the exemplary embodiments do not represent all implementations consistent with the present disclosure. Rather, they are merely examples of devices and methods consistent with aspects related to the present disclosure recited in the appended claims. Certain aspects of the present disclosure are described in more detail below. In case of conflict with terms and / or definitions incorporated by reference, the terms and definitions provided herein shall control.

[0012]

[0036] The ITU-T Video Coding Expert Group (ITU-T VCEG) and the ISO / IEC Moving Picture Expert Group (ISO / IEC MPEG) Joint Video Experts Team (JVET) are currently developing the Versatile Video Coding (VVC / H.266) standard. The VVC standard aims to double the compression efficiency of its predecessor, the High Efficiency Video Coding (HEVC / H.265) standard. In other words, the goal of VVC is to achieve the same subjective quality as HEVC / H.265 while 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 go beyond HEVC using the joint exploration model (JEM) reference software. As coding techniques are incorporated into JEM, JEM has achieved substantially higher coding performance than HEVC.

[0014]

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

[0015]

[0039] A video is a set of still pictures (or "frames") arranged in chronological order to store visual information. A video capture device (e.g., a camera) can be used to capture and store those pictures in chronological order, and a video playback device (e.g., a television, a computer, a smartphone, a tablet computer, a video player, or any end-user terminal with display capabilities) can be used to display such pictures in chronological order. Furthermore, in some applications, a video capture device can transmit captured videos in real time to a video playback device (e.g., a computer with a monitor) for surveillance, conferencing, live broadcast, etc.

[0016]

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

[0017]

[0041] A video coding process can identify and keep useful information that can be used to reconstruct a picture and ignore information that is not important for the reconstruction. If the ignored, unimportant information cannot be perfectly reconstructed, then such a coding process can be called "lossy". Otherwise, such a coding process can be called "lossless". Most coding processes are lossy, which is a tradeoff to reduce the required storage space and transmission bandwidth.

[0018]

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

[0019]

[0043] A picture that is coded without reference to another picture (i.e., such a picture is its own reference picture) is called an "I-picture." If some or all of the blocks in a picture (e.g., blocks that generally reference a portion of a video picture) are predicted using intra- or inter-prediction with one reference picture (e.g., unidirectional prediction), the picture is called a "P-picture." If at least one block in the picture is predicted with two reference pictures (e.g., bidirectional prediction), the picture is called a "B-picture."

[0020]

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

[0021]

[0045] 1 illustrates the structure of an example video sequence 100 according to some embodiments of the present disclosure. The video sequence 100 may be live video or captured and archived video. The video 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 FIG. 1, video sequence 100 may include a series of pictures arranged temporally along a timeline, including pictures 102, 104, 106, and 108. Pictures 102-106 are consecutive, with more pictures between pictures 106 and 108. In FIG. 1, picture 102 is an I-picture whose reference picture is picture 102 itself. Picture 104 is a P-picture whose reference picture is picture 102, as indicated by the arrow. Picture 106 is a B-picture whose reference pictures are pictures 104 and 108, as indicated by the arrow. In some embodiments, the reference picture of a picture (e.g., picture 104) may not be immediately preceding or following 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 of pictures 102-106 are merely examples, and this disclosure does not limit the embodiments of the reference pictures to the examples shown in FIG.

[0023]

[0047] Typically, a video codec does not encode or decode an entire picture at once because such a task is computationally complex. Rather, a video codec may divide a picture into elementary segments and encode or decode a picture segment by segment. In this disclosure, such elementary segments are referred to as basic processing units ("BPUs"). For example, structure 110 in FIG. 1 illustrates an example structure for a picture (e.g., any of pictures 102-108) of 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, the basic processing units may be referred to as "macroblocks" in some video coding standards (e.g., MPEG family, H.261, H.263, or H.264 / AVC) and as "coding tree units" ("CTUs") in some other video coding standards (e.g., H.265 / HEVC or H.266 / VVC). Basic processing units can have variable sizes within a picture, such as 128x128, 64x64, 32x32, 16x16, 4x8, 16x32, or any arbitrary shape and size of pixels. The size and shape of the basic processing unit can be selected for a picture based on a balance between efficiency of coding and the level of detail one wishes to preserve within the basic processing unit.

[0024]

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

[0025]

[0049] Video coding has multiple operation 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 therefore may be further divided into segments, referred to as "basic processing sub-units" in this disclosure. In some embodiments, the basic processing sub-units may be referred to as "blocks" in some video coding standards (e.g., MPEG family, H.261, H.263, or H.264 / AVC), or as "coding units" ("CUs") in some other video coding standards (e.g., H.265 / HEVC or H.266 / VVC). The basic processing sub-units may have the same or smaller size than the basic processing units. Similar to the basic processing units, the basic processing sub-units are also logical units that may include various types of video data (e.g., Y, Cb, Cr, and related syntax elements) stored in computer memory (e.g., in a video frame buffer). Any operation performed on a basic processing sub-unit can be repeated on each of its luma and chroma components. It should be noted that such division can be performed on further levels, depending on the processing needs. It should also be noted that different stages can use different schemes to divide the basic processing unit.

[0026]

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

[0027]

[0051] In another example, in the prediction stage (one example of which is shown in FIG. 2A-2B), the encoder can perform prediction operations at the level of the basic processing sub-unit (e.g., CU). However, in some cases, the basic processing sub-unit may still be too large to process. The encoder can further divide the basic processing sub-unit into smaller segments (e.g., called "prediction blocks" or "PBs" in H.265 / HEVC or H.266 / VVC) and perform prediction operations at that level.

[0028]

[0052] In another example, in the transform stage (one example of which is shown in FIG. 2A-2B), the encoder can perform a transform operation on the residual elementary processing sub-unit (e.g., CU). However, in some cases, the elementary processing sub-unit may still be too large to process. The encoder can further divide the elementary processing sub-unit into smaller segments (e.g., called "transform blocks" or "TBs" in H.265 / HEVC or H.266 / VVC) and perform the transform operation at that level. It should be noted that the division scheme of the same elementary processing sub-unit may be different between the prediction stage and the transform stage. For example, in H.265 / HEVC or H.266 / VVC, the prediction blocks and transform blocks of the same CU may have different sizes and numbers.

[0029]

[0053] In structure 110 of Figure 1, basic processing units 112 are further divided into 3x3 basic processing sub-units, the boundaries of which are shown by dotted lines. Different basic processing units of the same picture may be divided into basic processing sub-units in different ways.

[0030]

[0054] In some implementations, to provide video encoding and decoding with parallel processing and error resilience capabilities, a picture can be divided into regions for processing, such that for a region of a picture, the encoding or decoding process does not depend on information of any other region of the picture. In other words, each region of a picture can be processed independently. In this way, a codec can process different regions of a picture in parallel, thus increasing the efficiency of coding. Furthermore, if data of a region is corrupted in processing or lost in network transmission, the codec can correctly encode or decode other regions of the same picture without relying on the corrupted or lost data, thus providing error resilience capabilities. In some video coding standards, a picture can be divided into different types of regions. For example, H.265 / HEVC and H.266 / VVC provide two types of regions: "slices" and "tiles". It should also be noted that various pictures of the video sequence 100 may have different partitioning 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, whose boundaries are shown as solid lines within structure 110. Region 114 includes four basic processing units. Regions 116 and 118 each include six basic processing units. It should be noted that the basic processing units, basic processing sub-units, and regions of structure 110 in Figure 1 are merely examples, and the present disclosure is not limited to such embodiments.

[0032]

[0056] FIG. 2A illustrates 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 FIG. 2A, the encoder may encode a video sequence 202 into a video bitstream 228 according to the process 200A. Similar to the video sequence 100 of FIG. 1, the video sequence 202 may include a set of pictures (referred to as "original pictures") arranged in a chronological order. Similar to the structure 110 of FIG. 1, each original picture of the video sequence 202 may be divided by the encoder into elementary processing units, elementary processing sub-units, or regions for processing. In some embodiments, the encoder may perform the process 200A at the level of the elementary processing units for each original picture of the video sequence 202. For example, the encoder may perform the process 200A in an iterative manner, in which case the encoder may encode an elementary processing unit in one iteration of the process 200A. In some embodiments, the encoder may perform process 200A in parallel for each original picture region of video sequence 202 (eg, regions 114-118).

[0033]

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

[0034]

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

[0035]

[0059] Referring to process 200A, an encoder may receive a video sequence 202 generated by a video capture device (e.g., a camera). As used herein, the term "receive" may refer to any action of receiving, inputting, obtaining, retrieving, acquiring, reading, accessing, or any manner of inputting data.

[0036]

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

[0037]

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

[0038]

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

[0039]

[0063] Different transform algorithms may use different basis patterns. Different transform algorithms may be used in transform stage 212, for example, discrete cosine transform, discrete sine transform, etc. The transform in transform stage 212 is reversible. That is, the encoder may reconstruct residual BPU 210 by the inverse operation of the transform (referred to as "inverse transform"). For example, to reconstruct pixels of residual BPU 210, the inverse transform may be to multiply the values ​​of corresponding pixels of the basis pattern by the associated respective coefficients and add the products to result in a weighted sum. In a video coding standard, both the encoder and the decoder may use the same transform algorithm (and thus the same basis pattern). Thus, the encoder may record only the transform coefficients, in which case the decoder may reconstruct residual BPU 210 from the transform coefficients without receiving the basis pattern from the encoder. Although the transform coefficients may have fewer bits compared to residual BPU 210, they may be used to reconstruct residual BPU 210 without significant loss of quality. Therefore, the residual BPU 210 is further compressed.

[0040]

[0064] The encoder can further compress the transform coefficients in the quantization stage 214. In the transform process, different basis patterns can represent different fluctuation frequencies (e.g., luminance fluctuation frequencies). Since the human eye is generally good at recognizing low-frequency fluctuations, the encoder can ignore the information of high-frequency fluctuations without causing significant quality degradation during decoding. For example, in the quantization stage 214, the encoder can generate quantized transform coefficients 216 by dividing each transform coefficient by an integer value (called a "quantization scale factor") and rounding the quotient to its nearest neighbor. After such an operation, some transform coefficients of the high-frequency basis patterns can be converted to zero, and the transform coefficients of the low-frequency basis patterns can be converted to smaller integers. The encoder can ignore the zero-valued quantized transform coefficients 216, which further compresses the transform coefficients. The quantization process is also reversible, and the quantized transform coefficients 216 can be reconstructed into transform coefficients in an inverse operation of quantization (called "dequantization").

[0041]

[0065] The quantization stage 214 may be lossy because the encoder ignores the remainder of such a division in a rounding operation. Typically, the quantization stage 214 may contribute the greatest information loss in the process 200A. The greater the information loss, the fewer bits the quantized transform coefficients 216 may require. To obtain different levels of information loss, the encoder may use different values ​​of the quantization parameter or any other parameter of the quantization process.

[0042]

[0066] In the binary coding stage 226, the encoder may use a binary coding technique, such as, for example, entropy coding, variable length coding, arithmetic coding, Huffman coding, context-adaptive binary arithmetic coding, or any other lossless or lossy compression algorithm, to encode the prediction data 206 and the quantized transform coefficients 216. In some embodiments, in addition to the prediction data 206 and the quantized transform coefficients 216, the encoder may encode other information in the binary coding stage 226, such as, for example, a 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), encoder control parameters (e.g., bitrate control parameters), etc. The encoder may use the output data of the binary coding stage 226 to generate a video bitstream 228. In some embodiments, the video bitstream 228 may be further packetized for network transmission.

[0043]

[0067] Referring to the reconstruction path of process 200A, in an inverse quantization stage 218, the encoder may perform inverse quantization on the quantized transform coefficients 216 to generate reconstructed transform coefficients. In an inverse transform stage 220, the encoder may generate a reconstructed residual BPU 222 based on the reconstructed transform coefficients. The encoder may add the reconstructed residual BPU 222 to the predicted BPU 208 to generate a prediction reference 224 to be used in the next iteration of process 200A.

[0044]

[0068] It should be noted that other variations of the process 200A can be used to encode the video sequence 202. In some embodiments, an encoder can perform the stages of the process 200A in a different order. In some embodiments, one or more stages of the process 200A can be combined into a single stage. In some embodiments, a single stage of the process 200A can be separated into multiple stages. For example, the transform stage 212 and the quantization stage 214 can be combined into a single stage. In some embodiments, the process 200A can include additional stages. In some embodiments, the process 200A can omit one or more stages in FIG. 2A.

[0045]

[0069] 2B shows a schematic diagram of another example encoding process 200B consistent with an embodiment 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 coding standard (e.g., H.26x series). Compared to process 200A, the forward path of process 200B further includes a mode decision 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 pixels of one or more neighboring BPUs already coded in the same picture to predict the current BPU. That is, the prediction reference 224 in spatial prediction can 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 regions of one or more already coded pictures to predict the current BPU. That is, the prediction reference 224 in temporal prediction can 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 a spatial prediction stage 2042 and a temporal prediction stage 2044. For example, in the spatial prediction stage 2042, the encoder may perform intra prediction. With respect to an original BPU of a picture being encoded, the prediction reference 224 may include one or more neighboring BPUs that are encoded (in the forward path) and reconstructed (in the reconstruction path) in the same picture. The encoder may generate the predicted BPU 208 by extrapolating the neighboring BPUs. Extrapolation techniques may include, for example, linear extrapolation or linear interpolation, polynomial extrapolation or polynomial interpolation, etc. In some embodiments, the encoder may perform extrapolation at a pixel level, such as by extrapolating the value of the corresponding pixel for each pixel of the predicted BPU 208. The neighboring BPUs 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., bottom-left, bottom-right, top-left, or top-right of the original BPU), or any direction specified within the video coding standard used. In intra prediction, the prediction data 206 may include, for example, the positions (e.g., coordinates) of the neighboring BPUs used, the size of the neighboring BPUs used, parameters of the extrapolation, the orientation of the neighboring BPUs used relative to the original BPU, etc.

[0048]

[0072] In another example, in the temporal prediction stage 2044, the encoder may perform inter prediction. With respect to the original BPU of the current picture, the prediction reference 224 may include one or more pictures (called "reference pictures") that have been coded (in the forward path) and reconstructed (in the reconstruction path). In some embodiments, the reference pictures may be coded and reconstructed for each BPU. For example, the encoder may add the reconstructed residual BPU 222 to the predicted BPU 208 to generate a reconstructed BPU. Once all the reconstructed BPUs of the same picture are generated, the encoder may generate the reconstructed picture as the reference picture. The encoder may perform an operation of "motion estimation" to look for a matching region within the range of the reference picture (called a "search window"). The position of the search window in the reference picture may be determined based on the position of the original BPU in the current picture. For example, the search window may be centered at a location in the reference picture that has the same coordinates as the original BPU in the current picture and may extend over a predetermined distance. When the encoder identifies a region within the search window that is similar to the original BPU (e.g., by using a pel recursion algorithm, a block matching algorithm, etc.), the encoder can determine the region as a match region. The match region may have different (e.g., smaller, equal, larger, or differently shaped) dimensions than the original BPU. Because the reference picture and the current picture are separated in time in a timeline (e.g., as shown in FIG. 1), the match region can be considered to "move" to the position of the original BPU over time. The encoder can record the direction and distance of such movement as a "motion vector." If multiple reference pictures are used (e.g., like picture 106 in FIG. 1), the encoder can look 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 of each matching reference picture.

[0049]

[0073] Motion estimation can be used to identify various types of motion, such as, for example, translation, rotation, scaling, etc. In inter prediction, the prediction data 206 may include, for example, the location (e.g., coordinates) of the match region, a motion vector associated with the match region, a number of reference pictures, weights associated with the reference pictures, etc.

[0050]

[0074] To generate the predicted BPU 208, the encoder may perform an operation of "motion compensation." Motion compensation may be used to reconstruct the predicted BPU 208 based on the prediction data 206 (e.g., motion vectors) and the prediction reference 224. For example, the encoder may move the matching regions of the reference picture according to the motion vectors, in which the encoder may predict the original BPU of the current picture. If multiple reference pictures are used (e.g., such as picture 106 in FIG. 1), the encoder may move the matching regions of the reference pictures according to their respective motion vectors and average the pixel values ​​of the matching regions. In some embodiments, if the encoder assigns weights to the pixel values ​​of the matching regions of the respective matching reference pictures, the encoder may add a weighted sum of the pixel values ​​of the moved matching regions.

[0051]

[0075] In some embodiments, inter prediction can be unidirectional or bidirectional. Unidirectional inter prediction can use one or more reference pictures in the same temporal direction relative to the current picture. For example, picture 104 in FIG. 1 is a unidirectional inter predicted picture in which a reference picture (e.g., picture 102) precedes picture 104. Bidirectional inter prediction can use one or more reference pictures in both temporal directions relative to the current picture. For example, picture 106 in FIG. 1 is a bidirectional inter predicted picture in which 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 the process 200B, after the spatial prediction step 2042 and the temporal prediction step 2044, in a mode decision step 230, the encoder may select a prediction mode (e.g., one of intra prediction or inter prediction) for the current iteration of the 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 a cost function depending on the bitrate of the candidate prediction mode and the distortion of the reconstructed reference picture under the candidate prediction mode. Depending on the prediction mode selected, the encoder may generate a corresponding predicted BPU 208 and predicted data 206.

[0053]

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

[0054]

[0078] FIG. 3A shows a schematic diagram of an example of a decoding process 300A consistent with an embodiment of the present disclosure. The process 300A may be a decompression process corresponding to the compression process 200A of FIG. 2A. In some embodiments, the process 300A may be similar to the reconstruction path of the process 200A. A decoder may decode the video bitstream 228 into a video stream 304 according to the 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 process (e.g., the quantization stage 214 of FIGS. 2A-2B), the video stream 304 is generally not identical to the video sequence 202. Similar to the processes 200A and 200B of FIGS. 2A-2B, the decoder may perform the process 300A at the level of a basic processing unit (BPU) for each picture encoded in the video bitstream 228. For example, the decoder may perform process 300A in an iterative manner, where the decoder may decode a basic processing unit in one iteration of process 300A. In some embodiments, the decoder may perform process 300A in parallel for regions (e.g., regions 114-118) of each picture encoded in video bitstream 228.

[0055]

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

[0056]

[0080] The decoder may iteratively perform the process 300A to decode each coded BPU of the coded picture and generate a prediction reference 224 for coding the next coded BPU of the coded picture. After decoding all coded BPUs of the coded picture, the decoder may output the picture to the video stream 304 for display and proceed to decode the next coded picture in the video bitstream 228.

[0057]

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

[0058]

[0082] 3B shows a schematic diagram of another example of a decoding process 300B consistent with an embodiment of the present disclosure. The process 300B may be modified from the process 300A. For example, the process 300B may be used by a decoder that complies with a hybrid video coding standard (e.g., H.26x series). Compared to the process 300A, the 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 the process 300B, for a coded elementary processing unit (referred to as a "current BPU") of a coded picture (referred to as a "current picture") being decoded, the prediction data 206 decoded by the decoder from the binary decoding stage 302 may include various types of data depending on which prediction mode was used by the encoder to code the current BPU. For example, if intra prediction was used by the encoder to code the current BPU, the prediction data 206 may include a prediction mode indicator (e.g., a flag value) indicating intra prediction, parameters of the intra prediction operation, etc. The parameters of the intra prediction operation may include, for example, the location (e.g., coordinates) of one or more neighboring BPUs used as a reference, the size of the neighboring BPU, parameters of extrapolation, the direction of the neighboring BPU relative to the original BPU, etc. In another example, if inter prediction was used by the encoder to code the current BPU, the prediction data 206 may include a prediction mode indicator (e.g., a flag value) indicating inter prediction, parameters of the inter prediction operation, etc. Parameters for inter-prediction operations may include, for example, the number of reference pictures associated with the current BPU, weights respectively associated with the reference pictures, the locations (e.g., coordinates) of one or more matching regions within each reference picture, one or more motion vectors respectively associated with the matching regions, etc.

[0060]

[0084] Based on the prediction mode indicator, the decoder may decide whether to perform spatial prediction (e.g., intra prediction) in the spatial prediction stage 2042 or temporal prediction (e.g., inter prediction) in the temporal prediction stage 2044. Details of performing such spatial or temporal prediction are shown in FIG. 2B and will not be repeated below. After performing such spatial or temporal prediction, the decoder may generate a predicted BPU 208. As described in FIG. 3A, the decoder may add the predicted BPU 208 and the reconstructed residual BPU 222 to generate a prediction reference 224.

[0061]

[0085] In the process 300B, the decoder can feed the prediction reference 224 to the spatial prediction stage 2042 or the temporal prediction stage 2044 for performing a prediction operation in the next iteration of the process 300B. For example, if the current BPU is decoded using intra prediction in the spatial prediction stage 2042, after generating the prediction reference 224 (e.g., the decoded current BPU), the decoder can directly feed the prediction reference 224 to the 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 the temporal prediction stage 2044, after generating the prediction reference 224 (e.g., the reference picture to which all BPUs are decoded), the decoder can feed the prediction reference 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 reference 224 in the manner described in FIG. 2B. The loop filtered reference picture may be stored in a 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 the 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, when the prediction mode indicator of the prediction data 206 indicates that inter prediction was used to encode the current BPU, the prediction data includes loop filter parameters. The reconstructed picture from the buffer 234 may also be transmitted to a display, such as a TV, PC, smartphone, or tablet, for viewing by an end user.

[0062]

[0086] FIG. 4 is a block diagram of an example of a device 400 for encoding or decoding video consistent with an embodiment of the present disclosure. As shown in FIG. 4, the device 400 may include a processor 402. When the processor 402 executes instructions described herein, the device 400 may become a dedicated machine for encoding or decoding video. The processor 402 may be any type of circuitry capable of manipulating or processing information. For example, the processor 402 may include any combination of 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), complex programmable logic devices (CPLDs), field programmable gate arrays (FPGAs), systems on chips (SoCs), application specific integrated circuits (ASICs), and the like. In some embodiments, processor 402 may be a set of processors grouped together as a single logical entity. For example, as shown in FIG. 4, processor 402 may include multiple 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., a set of instructions, computer code, intermediate data, etc.). For example, as shown in FIG. 4, the stored data may include program instructions (e.g., program instructions for implementing steps in processes 200A, 200B, 300A, or 300B) and data for processing (e.g., video sequence 202, video bitstream 228, or video stream 304). The processor 402 may access the program instructions and data for processing (e.g., via bus 410) and execute the program instructions to operate on or process the data for processing. The memory 404 may include high-speed random access storage or non-volatile storage. In some embodiments, the memory 404 may include any combination of any number of random access memories (RAMs), read-only memories (ROMs), optical disks, magnetic disks, hard drives, solid-state drives, flash drives, security digital (SD) cards, memory sticks, compact flash (CF) cards, and the like. Memory 404 may also be a collection of memories (not shown in FIG. 4) grouped together as a single logical entity.

[0064]

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

[0065]

[0089] For ease of explanation and without ambiguity, the present disclosure refers to the processor 402 and other data processing circuitry collectively as the "data processing circuitry." The data processing circuitry may be implemented entirely as hardware or as a combination of software, hardware, or firmware. In addition, the data processing circuitry may be a single, independent module, or may be fully or partially combined within any other component of the device 400.

[0066]

[0090] 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 communications network, etc.) In some embodiments, 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, device 400 may further optionally include a peripheral interface 408 for providing connection to one or more peripheral devices. As shown in Figure 4, the peripheral devices may include, but are not limited to, a cursor control device (e.g., a mouse, a touchpad, or a touch screen), 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 an input interface coupled to a video archive), and the like.

[0068]

[0092] It should be noted that a video codec (e.g., a codec performing processes 200A, 200B, 300A, or 300B) may be implemented as any combination of any software or hardware modules within device 400. For example, some or all of the stages of processes 200A, 200B, 300A, or 300B may be implemented as one or more software modules of device 400, such as program instructions loadable into memory 404. In another example, some or all of the 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., FPGAs, ASICs, NPUs, etc.).

[0069]

[0093] FIG. 5 is a schematic diagram of an example 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 FIGS. 2A-2B and 3A-3B. In FIG. 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, the bitstream 500, which is a sequence of bits in the form of network abstraction layer (NAL) units or byte streams, forms one or more coded video sequences (CVS). A CVS includes one or more coded layer video sequences (CLVS). In some embodiments, a CLVS is a sequence of picture units (PUs), each PU including one coded picture. In particular, a PU includes zero or one picture header NAL unit (e.g., picture header 540), which includes as payload a picture header syntax structure, one or more video coding layer (VCL) NAL units, and optionally one or more other non-VCL NAL units. A VCL NAL unit is, in some embodiments, a generic term for coded slice NAL units (e.g., slices 550-570) and a subset of NAL units with a reserved value of NAL unit type that are classified as VCL NAL units. A coded slice NAL unit includes a slice header and a slice data block (eg, header 552 and data 554).

[0071]

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

[0072]

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

[0073]

[0097] As an example, Figure 6 is a schematic diagram illustrating a structure of a picture 600 partitioned into blocks, consistent with some embodiments of the present disclosure. In Figure 6, each square represents a CTU 610, and the picture 600 is partitioned into 8x6 CTUs 610. In some embodiments, the maximum allowed size of a luma block in a CTU is 128x128, and the maximum allowed size of a luma transform block is 64x64. In some embodiments, the minimum allowed size of a luma block in a CTU is 32x32. It should be noted that the maximum allowed size of a luma block, the maximum allowed size of a luma transform block, and the minimum allowed size of a luma block may be specified to be different values ​​and different shapes in various video coding standards, and the present disclosure does not limit them to the above-mentioned examples.

[0074]

[0098] Consistent with some embodiments of this disclosure, a picture may be partitioned into one or more tile rows and one or more tile columns. A "tile" in this disclosure may refer to a sequence of CTUs that cover a rectangular region of a picture. A "slice" in this disclosure may include an integer number of complete tiles, or an integer number of complete contiguous CTU rows within a tile of a picture.

[0075]

[0099] In some embodiments, a picture may be partitioned into slices in two modes: "raster scan slice mode" and "rectangular slice mode." In raster scan slice mode, a slice of a picture may include a complete sequence of tiles in the raster scan order of the picture. In rectangular slice mode, a slice of a picture may include 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 within 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, FIG. 7 is a schematic diagram illustrating a structure of a picture 700 partitioned in a raster scan slice mode, consistent with some embodiments of the present disclosure. In FIG. 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 four tile rows and three tile columns, whose boundaries are represented by thin solid lines superimposed on the dashed lines. Furthermore, the picture 700 is divided into three raster scan slices represented by different shading, whose boundaries are represented by thick solid lines superimposed on the dashed or thin solid lines. As shown in FIG. 7, a first slice includes tiles 712 and 714. A second slice includes tiles 716, 722-726, and 732-734. The third slice includes tiles 736 and 742 through 746. The three slices of picture 700 are partitioned in raster scan order, with each of the three slices including an integer number of complete tiles.

[0077]

[0101] As an example, FIG. 8 is a schematic diagram illustrating a structure of a picture 800 partitioned in a rectangular slice mode consistent with some embodiments of the present disclosure. In FIG. 8, each dashed square represents a CTU, and the picture 800 is partitioned into 16×14 CTUs. The CTUs of the picture 800 form 12 tiles including 4 tile rows and 5 tile columns, whose boundaries are represented by thin solid lines superimposed on the dashed lines. Furthermore, the picture 800 is divided into 9 rectangular slices represented in different shades, whose boundaries are represented by thick solid lines superimposed on the dashed or thin solid lines. As shown in FIG. 8, the 9 slices of the picture 800 are partitioned into rectangles forming 9 rectangular regions, and each of the 9 slices includes an integer number of complete tiles. For example, the first slice includes tiles 812 and 814. The second slice includes tiles 816 and 818. The third slice includes 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 illustrating the structure of a picture 900 partitioned in a rectangular slice mode consistent with some embodiments of the present disclosure. In Figure 9, each dashed square represents a CTU, and the picture 900 is partitioned into 16x14 CTUs. The CTUs of the picture 900 form four tiles 910, 920, 930, and 940, each including two tile rows and two tile columns, whose boundaries are represented by dashed lines. For example, the first tile 910 may be at the top left with a size of 7x10 CTU. The second tile 920 may be at the bottom left with a size of 7x4 CTU. The third tile 930 may be at the top right with a size of 9x10 CTU. The fourth tile 940 may be at the bottom right with a size of 9x4 CTU. Furthermore, the picture 900 is divided into four rectangular slices represented by different shading, whose boundaries are represented by dashed lines or thick solid lines superimposed on thin solid lines. As shown in FIG. 9, the four slices of the picture 900 are partitioned into rectangles forming four rectangular regions, each of the four slices including an integer number of complete tiles or an integer number of consecutive complete CTU rows within the tiles of the picture 800. For example, the first slice (represented in white) may have a size of 7×14 CTU and include two complete tiles 910 and 920. The second slice (represented in grey) may have a size of 9×4 CTU and include one portion of the tile 930 (e.g., portion 932). The third slice (represented in white) may have a size of 9×6 CTU and include another portion of the tile 930 (e.g., portion 934). The fourth slice (represented in grey) may have a size of 9×4 CTU and include one complete tile 940.

[0079]

[0103] As an example, Figure 10 is a schematic diagram illustrating the structure of a picture 1000 partitioned in rectangular slice mode consistent with some embodiments of the present disclosure. In Figure 10, each dashed square represents a CTU, and the picture 1000 is partitioned into 16x16 CTUs. The CTUs of the picture 1000 form 20 tiles 1012-1019, 1022-1029, 1032-1039, and 1042-1049, which include four tile rows and five tile columns, and whose boundaries are represented by thin solid lines superimposed on the dashed lines. As shown in Figure 10, the left 12 tiles (e.g., tiles 1012-1016, 1022-1026, 1032-1036, and 1042-1046) each cover one slice of the 4x4 CTU. The eight tiles on the right (e.g., tiles 1018, 1019, 1028, 1029, 1038, 1039, 1048, and 1049) each cover two vertically stacked slices of the 2x2 CTU, resulting in 28 slices of different shading, each of which is a subpicture. For example, tile 1018 covers vertically stacked slices 1018a and 1018b, tile 1028 covers vertically stacked slices 1028a and 1028b, etc. Slice / subpicture boundaries are represented by thick dashed lines.

[0080]

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

[0081]

[0105] In FIG. 11, the SPS flag 1110 ("sps_subpic_info_present_flag"), when equal to 1, may specify that sub-picture information is present for the CLVS and that there may be one or more sub-pictures for each picture in the CLVS. Consistent with the above disclosure, a CLVS is a group of pictures that belong to the same layer, starting with a random access point, followed by pictures that may depend on each other and a random access point picture. When the SPS flag 1110 is equal to 0, there is no sub-picture information for the CLVS and there is only one sub-picture for each picture in the CLVS. In some embodiments, the SPS flag "sps_res_change_in_clvs_allowed_flag" equal to 1 specifies that the value of the SPS flag 1110 is equal to 0. When a bitstream is the result of a sub-bitstream extraction process and contains only a subset of the sub-pictures of the input bitstream to the sub-bitstream extraction process, it may be necessary to set the value of the SPS flag 1110 to 1 in the Raw Byte Sequence Payload ("RBSP") of the Sequence Parameter Set ("SPS").

[0082]

[0106] In FIG. 11, the SPS syntax element "sps_num_subpics_minus1" (e.g., syntax element 1112 in FIG. 11) + 1 specifies the number of subpictures in each picture in CLVS. The value of syntax element 1112 ("sps_num_subpics_minus1") is in the range from 0 to (ceil(sps_pic_width_max_in_luma_samples÷CtbSizeY)×ceil(sps_pic_height_max_in_luma_samples÷CtbSizeY)−1), inclusive. If not present, the value of syntax element 1112 ("sps_num_subpics_minus1") is determined to be equal to 0.

[0083]

[0107] In Figure 11, the SPS flag 1120 ("sps_independent_subpics_flag"), when equal to 1, may specify that all sub-picture boundaries in the CLVS are treated as picture boundaries and there is no loop filtering across sub-picture boundaries. No such constraint is imposed by the SPS flag 1120 being equal to 0. The value of the SPS flag 1120 is determined to be equal to 1 if not present.

[0084]

[0108] In FIG. 11, the SPS syntax element "sps_subpic_ctu_top_left_x[i]" (e.g., syntax element 1122 in FIG. 11) specifies the horizontal location 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 determined to be equal to 0 if not present.

[0085]

[0109] Similarly, the SPS syntax element "sps_subpic_ctu_top_left_y[i]" (e.g., syntax element 1124 in FIG. 11) specifies the vertical position of the top-left CTU of the ith 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 determined to be equal to 0 if not present.

[0086]

[0110] In FIG. 11, the SPS syntax element "sps_subpic_width_minus1[i]" (e.g., syntax element 1126 in FIG. 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 not present, 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 FIG. 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 not present, the value of the SPS syntax element "sps_subpic_height_minus1[i]" is determined to be equal to ((ps_pic_height_max_in_luma_samples+CtbSizeY-1)>>(CtbLog2SizeY)-sps_subpic_ctu_top_left_y[i]-1).

[0088]

[0112] In some embodiments, to meet bitstream conformance, the shape of the subpictures is such that each subpicture, upon decoding, has its entire left and top boundaries either including the picture boundary or including the boundary of a previously decoded subpicture.

[0089]

[0113] In some embodiments, for each subpicture with subpicture index i in the range from 0 to the value of syntax element 1112, the following conditions are true to satisfy bitstream conformance: First, 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). Second, 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). Third, 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). Fourth, 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 FIG. 11, the SPS flag 1130 ("sps_subpic_treated_as_pic_flag[i]"), when equal to 1, may specify that the i-th sub-picture of each coded picture in the CLVS is treated as a picture in the decoding process except for in-loop filtering operations. The SPS flag 1130 equal to 0 specifies that the i-th sub-picture of each coded picture in the CLVS is not treated as a picture in the decoding process except for in-loop filtering operations. If not present, 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" (e.g., syntax element 1112 of FIG. 11) is greater than 0 and the SPS flag 1130 is equal to 1, for each CLVS of the current layer that references 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 decoding order through the AU containing the last picture of the CLVS in decoding order, inclusive. In some embodiments, to satisfy bitstream conformance, the following conditions are true for a target set of layers ("targetLayerSet") that includes the current layer and layers that use the current layer as a reference layer: First, for each AU in the targetAuSet, all pictures of layers in the targetLayerSet have the same value of pps_pic_width_in_luma_samples and the same value of pps_pic_height_in_luma_samples. Second, all SPSs referenced by layers in targetLayerSet have the same value of syntax element 1112, and the same values ​​of 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], respectively, for each value of j ranging from 0 to syntax element 1112, inclusive. Third, for each AU in targetAuSet, all pictures of layers in targetLayerSet have the same value of SubpicIdVal[j] for each value of j ranging from 0 to syntax element 1112, inclusive.

[0092]

[0116] In Figure 11, flag 1140 ("sps_loop_filter_across_subpic_enabled_flag[i]"), when equal to 1, specifies that in-loop filtering operations across subpicture boundaries are enabled and may be performed across the boundary of the i-th subpicture in each coded picture in the CLVS. When flag 1140 is equal to 0, flag 1140 specifies that in-loop filtering operations across subpicture boundaries are disabled and are not performed across the boundary of the i-th subpicture in each coded picture in the CLVS. The value of flag 1140 is determined to be equal to 0 if not present.

[0093]

[0117] The SPS syntax element "sps_subpic_id_len_minus1" (e.g., syntax element 1142 in FIG. 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 from 0 to 15, inclusive. 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 sub-picture ID mapping is explicitly signaled in either the SPS or PPS referenced by a coded picture in the CLVS. When flag 1150 is equal to 0, flag 1150 specifies that sub-picture ID mapping is not explicitly signaled for the CLVS. The value of flag 1150 is determined to be equal to 0 if not present.

[0095]

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

[0096]

[0120] The SPS syntax element "sps_subpic_id[i]" (e.g., syntax element 1162 in FIG. 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 the value of "sps_subpic_id_len_minus1" + 1 bit.

[0097]

[0121] In some embodiments, tile mapping information for tiles and slice partitions may be signaled in a picture parameter set (PPS). Figure 12 shows an example coding syntax table of a portion of a PPS syntax structure 1200 for signaling tile mapping and slices within a 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 FIG. 12, the PPS flag 1210 ("pps_no_pic_partition_flag") may specify that picture partitioning is not applied to any picture that references the PPS (including the PPS flag 1210) when the PPS flag 1210 is equal to 1, and may specify that each picture that references the PPS may be partitioned into more than one tile or slice when the PPS flag 1210 is equal to 0. In some embodiments, it is a bitstream compatibility requirement that the value of the PPS flag 1210 is the same for all PPSs referenced by coded pictures in a coded layer video sequence (CLVS). In some embodiments, it is also a bitstream compatibility requirement that the value of the PPS flag 1210 is equal to 0 when the value of the syntax element 1112 ("sps_num_subpics_minus1") is greater than 0 or when the value of the syntax element "pps_mixed_nalu_types_in_pic_flag" is equal to 1.

[0099]

[0123] In FIG. 12 , a value of flag 1220 ("pps_subpic_id_mapping_present_flag") equal to 1 specifies that sub-picture ID mapping is signaled in the PPS. A value of flag 1220 equal to 0 specifies that sub-picture 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, the value of flag 1220 is equal to 0. If SPS flag 1150 is equal to 1 and SPS flag 1160 is equal to 0, the value of flag 1220 is equal to 1.

[0100]

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

[0101]

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

[0102]

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

[0103]

[0127] 13 illustrates an example pseudocode for deriving a value for the variable SubpicIdVal, according to some embodiments of the present disclosure. As illustrated in FIG. 13, for each value of index i in the range of 0 to syntax element 1112 ("sps_num_subpics_minus1"), a value for the variable SubpicIdVal may be derived. In some embodiments, to satisfy bitstream conformance, both of the following constraints are applied: First, for any two distinct values ​​of index i and index j in the range of 0 to syntax element 1112 ("sps_num_subpics_minus1"), SubpicIdVal[i] is not equal to SubpicIdVal[j]. Second, for each value of index i in the range 0 to syntax element 1112 ("sps_num_subpics_minus1"), if the value of SubpicIdVal[i] of the current picture with nuh_layer_id equal to a particular value layerId is not equal to the value of SubpicIdVal[i] of a reference picture with nuh_layer_id equal to layerId, then the active entries in the reference picture list ("RPL") of the coded slice in the i-th subpicture of the current picture do 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 coding treeblock 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 FIG. 12, the value of the syntax element "pps_num_exp_tile_columns_minus1" (e.g., syntax element 1232 in FIG. 12)+1 specifies the number of tile column widths that are explicitly provided. In some embodiments, the value of syntax element 1232 is in the range from 0 to (PicWidthInCtbsY-1), inclusive. When PPS flag 1210 is equal to 1, the value of syntax element 1232 is determined to be 0.

[0106]

[0130] In FIG. 12, the value of the syntax element "pps_num_exp_tile_rows_minus1" (e.g., syntax element 1234 in FIG. 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 from 0 to (PicHeightInCtbsY-1), inclusive. When PPS flag 1210 is equal to 1, the value of syntax element 1234 is determined to be 0.

[0107]

[0131] In FIG. 12, the value of syntax element "pps_tile_column_width_minus1[i]" (e.g., syntax element 1236 in FIG. 12)+1 specifies the width of the ith tile column in units of CTBs, where index i ranges from 0 to syntax element 1232 inclusive. In some embodiments, syntax element "pps_tile_column_width_minus1[num_exp_tile_columns_minus1]" may be used to derive the width of tile columns with indices greater than syntax element 1232 as specified herein. The value of syntax element 1236 ranges from 0 to (PicWidthInCtbsY-1) inclusive. The value of syntax element "pps_tile_column_width_minus1[0]" is determined to be equal to "PicWidthInCtbsY-1" if not present in the PPS.

[0108]

[0132] In FIG. 12 , the value of syntax element “pps_tile_row_height_minus1[i]” (e.g., syntax element 1238 in FIG. 12 )+1 specifies the height of the i-th tile row in units of CTBs, where index i ranges from 0 to syntax element 1234 inclusive. In some embodiments, syntax element “pps_tile_row_height_minus1[pps_num_exp_tile_rows_minus1]” may be used to derive the height of tile rows with indices greater than syntax element 1234 as specified herein. The value of 1238 ranges from 0 to (PicHeightInCtbsY-1) inclusive. The value of syntax element “pps_tile_row_height_minus1[0]” is determined to be equal to “PicHeightInCtbsY-1” when not present in the PPS.

[0109]

[0133] In FIG. 12, flag 1230 ("pps_loop_filter_across_tiles_enabled_flag"), when equal to 1, specifies that in-loop filtering operations across tile boundaries are enabled and may be performed across tile boundaries in pictures that reference the PPS. When flag 1230 is equal to 0, flag 1230 specifies that in-loop filtering operations across tile boundaries are disabled and are not performed across tile boundaries in pictures that reference the PPS. In-loop filtering operations include a deblocking filter, a sample adaptive offset filter, and an adaptive loop filter operation. The value of flag 1230 is determined to be equal to 1 when not present.

[0110]

[0134] In FIG. 12, flag 1240 ("pps_rect_slice_flag"), when equal to 0, specifies that the tiles in each slice are in raster scan order and that slice information is not signaled in the PPS. Flag 1240, when equal to 1, specifies that the tiles in each slice cover a rectangular region of the picture and that slice information is signaled in the PPS. Flag 1240 may be determined to be equal to 1 when not present in the 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") specifies that each subpicture may contain one or more rectangular slices when it is equal to 0. Flag 1250 specifies that each subpicture contains one single rectangular slice when it is equal to 1. Flag 1250 is determined to be equal to 1 when not present.

[0112]

[0136] In FIG. 12, the syntax element "pps_num_slices_in_pic_minus1" (e.g., syntax element 1252 in FIG. 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") ranges from 0 to (the value of syntax element "MaxSlicesPerPicture" minus 1). The syntax element "MaxSlicesPerPicture" indicates a level restriction on the maximum allowed number of slices 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, picture partition is not 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 pps_tile_idx_delta_val[i] syntax element is not present in the PPS, and that a picture referencing the PPS is partitioned into rectangular slice rows and rectangular slice columns in raster scan order. When flag 1260 is equal to 1, it specifies that the pps_tile_idx_delta_val[i] syntax element may be present in the PPS, and that rectangular slices in a picture referencing the PPS are specified in the order indicated by the value of the pps_tile_idx_delta_val[i] syntax element as the value of index i increases. The value of flag 1260 is determined to be equal to 0 when not present.

[0115]

[0139] In FIG. 12, the syntax element "pps_slice_width_in_tiles_minus1[i]" (e.g., syntax element 1262 in FIG. 12)+1 specifies the width of the i-th rectangular slice in units of a tile column. In some embodiments, the value of syntax element 1262 ("pps_slice_width_in_tiles_minus1[i]") is in the range from 0 to ("NumTileColumns-1) inclusive. The value of syntax element 1262 ("pps_slice_width_in_tiles_minus1") is determined to be equal to 0 when not present 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 in units of a tile row. In some embodiments, the value of syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") is in the range from 0 to (NumTileRow-1), inclusive. When syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") is not present in the PPS, if the value of "SliceTopLeftTileIdx[i] / NumTileColumns" is equal to the value of "NumTileRows-1", the value of syntax element 1264 is determined to be equal to 0, and 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 FIG. 12, the value of the syntax element "pps_num_exp_slices_in_tile[i]" (e.g., syntax element 1266 of FIG. 12) specifies the number of slice heights explicitly given to slices in a 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]") ranges from 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1). The value of syntax element 1266 is determined to be equal to 0 when not present. When syntax element 1266 is equal to 0, the value of 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 +1 of the syntax element "pps_exp_slice_height_in_ctus_minus1[i][j]" (e.g., syntax element 1268 in Figure 12) specifies the height of the jth rectangular slice in the tile that contains the ith slice of the unit in the CTU row. When syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is greater than 0 (i.e., the tile may be divided into multiple slices), the index j is in the range from 0 to (pps_num_exp_slices_in_tile[i]-1), inclusive.

[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 the rectangular slices in the tile containing the i-th slice with 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 from 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1). That is, the maximum possible value of the height of any rectangular slice in the tile should be the height of the current tile.

[0120]

[0144] In FIG. 12, the syntax element "pps_tile_idx_delta_val[i]" (e.g., syntax element 1272 in FIG. 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]") shall be in the range of (-NumTilesInPic+1) to (NumTilesInPic-1). The value of syntax element 1272 is determined to be equal to 0 when not present. The value of syntax element 1272 is not equal to 0 when present.

[0121]

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

[0122]

[0146] In Figure 12, flag 1270 ("pps_loop_filter_across_slices_enabled_flag"), when equal to 1, specifies that in-loop filtering operations across slice boundaries are enabled and may be performed across slice boundaries in pictures that reference the PPS. When flag 1270 is equal to 0, flag 1270 specifies that in-loop filtering operations across slice boundaries are disabled and are not performed across slice boundaries in pictures that reference the PPS. In-loop filtering operations include a deblocking filter, a sample adaptive offset filter, and an adaptive loop filter operation. The value of flag 1270 is determined to be equal to 0 when not present.

[0123]

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

[0124]

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

[0125]

[0149] A list tileColBd[i], for i in the range 0 to NumTileColumns, inclusive, may be derived that specifies the location of the ith tile column boundary of the unit of the CTB. Figure 16 shows example pseudocode including the derivation of the variable tileColBd[i], in accordance with some embodiments of the present disclosure. As shown in Figure 16, the size of the array tileColBd[] is one greater than the actual number of tile columns.

[0126]

[0150] A list tileRowBd[j], for j in the range 0 to NumTileRows, inclusive, that specifies the location of the jth tile row boundary of the unit of the CTB, may be derived. Figure 17 shows example pseudocode including the derivation of the variable tileRowBd[j], in accordance with some embodiments of the present disclosure. As shown in Figure 17, the size of the array tileRowBd[] is one greater than the actual number of tile rows.

[0127]

[0151] Lists CtbToTileColBd[ctbAddrX] and ctbToTileColIdx[ctbAddrX] may be derived for ctbAddrX in the range 0 to PicWidthInCtbsY, which specify the translation from the horizontal CTB address to the left tile column boundary and the translation to the tile column index, respectively, in units of CTB. Figure 18 shows example pseudocode including the derivation of variables CtbToTileColBd and ctbToTileColIdx, in accordance with some embodiments of the present disclosure. As shown in Figure 18, the size of the arrays CtbToTileColBd[] and ctbToTileColIdx[] is one greater than the actual picture width in CTB.

[0128]

[0152] Lists CtbToTileRowBd[ctbAddrY] and ctbToTileRowIdx[ctbAddrY] for ctbAddrY in the range 0 to PicHeightInCtbsY, which specify the translation from the vertical CTB address to the top tile column boundary and the tile row index, respectively, in units of CTB, may be derived. Figure 19 shows example pseudocode including the derivation of variables CtbToTileRowBd and ctbToTileRowIdx, in accordance with some embodiments of the present disclosure. As shown in Figure 19, the size of the arrays CtbToTileRowBd[] and ctbToTileRowIdx[] is one greater than the actual picture height in CTB.

[0129]

[0153] Lists SubpicWidthInTiles[i] and SubpicHeightInTiles[i], for i, in the range from 0 to 1112 ("sps_num_subpics_minus1"), inclusive, that specify the width and height of the ith subpicture in a tile column and row, respectively, and a list subpicHeightLessThanOneTileFlag[i], for i, in the range from 0 to 1112 ("sps_num_subpics_minus1"), inclusive, that specifies whether the height of the ith subpicture is less than one tile row, may be derived. FIG. 20 shows example pseudocode including the derivation of variables SubpicWidthInTiles and SubpicHeightInTiles, in accordance with some embodiments of the present disclosure. As shown in FIG. 20, when a tile is partitioned into multiple rectangular slices and only a subset of the rectangular slices of a tile is included in the ith subpicture, the tile is counted as one tile in the value of SubpicHeightInTiles[i].

[0130]

[0154] When flag 1240 ("pps_rect_slice_flag") is equal to 1, a list NumCtusInSlice[i], for i, in the range 0 to 1 of syntax element 1252 ("pps_num_slices_in_pic_minus1"), specifies the number of CTUs in the i-th slice; a list Sli, for i, in the range 0 to 1 of syntax element 1252 ("pps_num_slices_in_pic_minus1"), specifies the tile index of the tile that contains the first CTU in the slice. ceTopLeftTileIdx[i], matrices CtbAddrInSlice[i][j] for i in the range 0 to (NumCtusInSlice[i]-1), inclusive, and j in the range 0 to (NumCtusInSlice[i]-1), inclusive, that specify the picture raster scan address of the jth CTB in the ith slice, and a variable NumSlicesInTile[i] that specifies the number of slices in the tile that contains the ith slice, may be derived. Figures 21 and 22 show example pseudocode including the derivation of the variables NumCtusInSlice, SliceTopLeftTileIdx, CtbAddrInSlice, and NumSlicesInTile, in accordance with some embodiments of the present disclosure.

[0131]

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

[0132]

[0156] Lists NumSlicesInSubpic[i], SubpicLevelSliceIdx[j], and SubpicIdxForSlice[j] may be derived that specify the number of slices in the i-th subpicture, the subpicture level slice index of the slice with picture level slice index j, and the subpicture index of the slice with picture level slice index j, respectively. Figure 23 shows example pseudocode including the derivation of the variables NumSlicesInSubpic, SubpicLevelSliceIdx, and SubpicIdxForSlice in accordance with some embodiments of the present disclosure.

[0133]

[0157] An embodiment of the present disclosure provides for signaling a flag in the SPS indicating whether a picture in the current CLVS is partitioned into more than one tile or slice, and signaling a flag in the PPS having the same value as the flag signaled in the SPS. Figure 24 shows an example coding syntax table with bold highlighting of a portion of an SPS syntax structure 2400 signaled in the SPS consistent with some embodiments of the present disclosure. The syntax structure 2400 is modified based on the syntax 1100 of Figure 11. As shown in Figure 24, the changes from the previous syntax shown in Figure 11 are indicated by a highlighted pattern.

[0134]

[0158] In comparison with the SPS syntax shown in Figure 11, in some embodiments, an SPS flag 2410 ("sps_no_pic_partition_flag") is signaled before the SPS flag 1110 in the SPS syntax shown in Figure 24. An SPS flag 2410 ("sps_no_pic_partition_flag") equal to 1 specifies that picture partitioning is not 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.

[0135]

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

[0136]

[0160] Additionally, 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. Because a subpicture is a set of slices, when there is no slice partition (e.g., the SPS syntax element flag is 1), there will be no subpicture partition (e.g., the SPS syntax element 1112 is 0).

[0137]

[0161] 25 illustrates another example coding syntax table of a portion of an SPS syntax structure 2500 signaled in an SPS, with bold highlighting, consistent with certain embodiments of the present disclosure. The syntax structure 2500 is also modified based on the syntax structure 1100 of FIG 11. As shown in FIG 25, the changes from the previous syntax shown in FIG 11 are indicated by the highlighted pattern.

[0138]

[0162] As mentioned above, in some embodiments, the number of sub-pictures may be only one when the SPS flag 2410 ("sps_no_pic_partitoin_flag") is equal to 1. 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 FIG. 25, the SPS flag 1110 ("sps_subpic_info_present_flag") may be 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 the SPS does not allow partitioning of a picture, no sub-picture information is present.

[0139]

[0163] In the syntax of FIG. 25, an SPS flag 2410 ("sps_no_pic_partitoin_flag") equal to 1 specifies that picture partitioning is not 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 FIG. 25, an SPS flag 1110 ("sps_subpic_info_present_flag") equal to 1 specifies that sub-picture information is present for the CLVS, and one or more sub-pictures may be present in each picture of the CLVS. An SPS flag 1110 ("sps_subpic_info_present_flag") equal to 0 specifies that sub-picture information is not present for the CLVS, and only one sub-picture is present in each picture of the CLVS. The value of the SPS flag 1110 ("sps_subpic_info_present_flag") may be determined to be equal to 0 if not present.

[0140]

[0164] 26 illustrates another example coding syntax table of a portion of an SPS syntax structure 2600 signaled in an SPS, with bold highlighting, consistent with certain embodiments of the present disclosure. The syntax structure 2600 is also modified based on the syntax structure 1100 of FIG 11. As shown in FIG 26, the changes from the previous syntax shown in FIG 11 are indicated by the highlighted pattern.

[0141]

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

[0142]

[0166] In the syntax of Figure 26, an SPS flag 2410 ("sps_no_pic_partitoin_flag") equal to 1 specifies that picture partitioning is not 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 26, an SPS flag 1112 ("sps_num_subpics_minus1") + 1 specifies the number of subpictures in each picture in the CLVS. The value of the SPS flag 1112 ("sps_num_subpics_minus1") is in the range from 0 to (Ceil(sps_pic_width_max_in_luma_samples÷CtbSizeY) × Ceil(sps_pic_height_max_in_luma_samples÷CtbSizeY) - 1), inclusive. The value of the SPS flag 1112 ("sps_num_subpics_minus1") may be determined to be equal to 0 if not present.

[0143]

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

[0144]

[0168] 27A-27C show flowcharts of example video encoding or decoding methods 2700A, 2700B, and 2700C, respectively, consistent with certain embodiments of the present disclosure. By applying any of the video encoding 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 the SPS, the values ​​of the SPS syntax elements or flags may be determined or assigned accordingly. In some embodiments, methods 2700A-2700C may be performed by an encoder (e.g., an encoder performing process 200A of FIG. 2A or process 200B of FIG. 2B) or a decoder (e.g., a decoder performing decoding process 300A of FIG. 3A or decoding process 300B of FIG. 3B) to generate or decode bitstream 500 shown in FIG. 5. For example, the encoder or decoder may be implemented as one or more software or hardware components of an apparatus (e.g., apparatus 400 of FIG. 4) for encoding or transcoding a video sequence (e.g., video sequence 202 of FIG. 2A or 2B) to generate a bitstream for the video sequence (e.g., video bitstream 228 of FIG. 2A or 2B), or for decoding a bitstream (e.g., video bitstream 228 of FIG. 3A or 3B) to reconstruct a video stream of the bitstream (e.g., video stream 304 of FIG. 3A or 3B). For example, one or more processors (eg, processor 402 of FIG. 4) may perform methods 2700A-2700C.

[0145]

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

[0146]

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

[0147]

[0171] In step 2730, the device is configured to determine whether the SPS flag 1110 is equal to 1. In response to the SPS flag 1110 being 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] In response to the SPS flag 1110 being 1 (step 2730-YES), the device is configured to perform step 2740 and encode or decode 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 that references the SPS. In particular, (SPS syntax element 1112+1) specifies the number of subpictures in each picture in the CLVS. Although this example flowchart references the SPS flag 1110 when equal to 1, resulting in step 2740 being executed, it should be understood that the 0 and 1 indications are design choices and that the results may be reversed for the SPS flag 1110 and other syntax elements (e.g., SPS flag 1110 being equal to 0 resulting in step 2740 being executed).

[0149]

[0173] In step 2750, the device is configured to encode or decode, in a picture parameter set (PPS) following the SPS, a PPS flag 1210 ("pps_no_pic_partition_flag") that is equal to the SPS flag 1110 to indicate whether a picture referencing the PPS is partitionable.

[0150]

[0174] The syntax structure 2500 shown in FIG. 25 may be applied to the method 2700B. Compared with the method 2700A, in the method 2700B, after step 2170, the device is configured to perform step 2715 and determine whether the SPS flag 2410 is equal to 0 (indicating that the picture associated with the SPS is partitionable). In response to the SPS flag 2410 being 1 (step 2715-no), indicating that the picture associated with the SPS is not partitioned, 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 the signaling of the SPS flag 1110 is skipped.

[0151]

[0175] The syntax structure 2600 shown in FIG. 26 may be applied to the method 2700C. Compared with the methods 2700A and 2700B, in the method 2700C, in response to the SPS flag 1110 being 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. In response to the SPS flag 2410 being 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 associated with the number of sub-pictures 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 the present disclosure provide an updated method of signaling flag 1240 ("pps_rect_slice_flag"). Figure 28 illustrates an example modified coding syntax table of a portion of a PPS syntax structure 2800 including an updated flag indicating rectangular slice mode or raster scan slice mode in accordance with some embodiments of the present 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 indicating whether rectangular slice mode or raster scan slice mode is used. As shown in FIG. 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 in rectangular slice mode. Thus, when the number of tiles is equal to 1, there is no need to use raster scan slice mode or to signal flag 1240 ("pps_rect_slice_flag"). Thus, the 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, the signaling of flag 1240 is not necessary and is redundant. When the number of tiles in a picture is less than four, there is at most one tile column or one tile row in the picture, and thus, the raster scan slices may also be represented in rectangular slices. Therefore, in some embodiments, the slice partitions of the raster scan slices are represented in rectangular slice mode as long as the number of tiles is less than four. In other words, when the number of tiles is two or three, the partitions may be represented in rectangular slice mode. By adopting this modification, the consistency and efficiency of the encoding and decoding process for the video stream may be improved.

[0156]

[0180] Thus, as shown in FIG. 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 FIG. 28, flag 1240 ("pps_rect_slice_flag") equal to 0 specifies that raster scan slice mode is in use for each picture that references the PPS (i.e., tiles within 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 rectangular slice mode is in use for each picture that references the PPS (i.e., tiles within each slice cover a rectangular area of ​​the picture), and slice information is signaled in the PPS. When not present, flag 1240 ("pps_rect_slice_flag") is determined to be 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, the value of flag 1240 ("pps_rect_slice_flag") is equal to 1.

[0157]

[0181] 29 illustrates a flowchart of an example video encoding or decoding method 2900 consistent with certain embodiments of the present disclosure. Similar to methods 2700A-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 of FIG. 4) for encoding or transcoding a video sequence or for decoding a bitstream to reconstruct a video stream. For example, one or more processors (e.g., processor 402 of FIG. 4) may perform method 2900.

[0158]

[0182] The syntax structure 2800 shown in FIG. 28 may be applied to the method 2900. In step 2910, the device is configured to code 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 mentioned above, in some embodiments, for pictures in the same CLVS, different PPSs may independently signal PPS flags 1210 with different values. For example, in step 2910, the device may code or decode a first flag indicating whether a first picture referencing the first PPS is partitioned into tiles or slices in a first PPS, and code or decode a second flag indicating whether a second picture referencing the second PPS is partitioned in a second PPS, where the first flag and the second flag have different values. For example, a first flag having a first value may indicate that a first picture of the CLVS is not partitioned, while a second flag having a second value different from the first value may indicate that a second picture is partitionable, i.e., a second picture of the CLVS can be partitioned, but the second picture may also not be partitioned.

[0159]

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

[0160]

[0184] In response to the number of tiles of the picture being greater than the 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 a raster scan slice mode is applied to a picture that references a PPS, the flag 1240 ("pps_rect_slice_flag") having a first value (e.g., 0) is encoded or decoded, and when a rectangular slice mode is applied to a picture that references a PPS, the flag 1240 ("pps_rect_slice_flag") having a second value different from the first value (e.g., 1) is encoded or decoded.

[0161]

[0185] In response to the number of tiles of the picture not being greater than the threshold (step 2920-no), step 2930 is skipped. In some embodiments, when the 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 the rectangular slice mode is applied.

[0162]

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

[0163]

[0187] The method 2900 removes the constraint so that different PPSs associated with pictures in the same CLVS may signal PPS flags 1210 with different values. In addition, the signaling of flags 1240 may 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 the partition.

[0164]

[0188] In VVC (e.g., VVC Draft 9), according to the definition of the 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 the picture. In the second case, a rectangular slice contains several consecutive complete CTU rows of one tile that collectively form a rectangular region of the picture. However, the semantics of pps_slice_flag specify the first case only when pps_slice_flag is equal to 1. As a result, the 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 the case where a rectangular slice includes one or more complete tiles (e.g., a first slice including complete tiles 910 and 920 of FIG. 9) and the case where a tile includes one or more slices (e.g., tile 930 including portions 932 and 934 corresponding to the second and third slices of FIG. 9) are specified in the semantics of flag 1240 ("pps_rect_slice_flag") equal to 1. In other words, the semantics for flag 1240 is modified to reflect that flag 1240 ("pps_rect_slice_flag") equal to 1 specifies that tiles within each slice cover a rectangular region of the picture, "i.e., each slice within a tile covers a rectangular region 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 ("pps_rect_slice_flag") equal to 1 specifies that tiles within each slice cover a rectangular region of the picture, "i.e., each slice within a tile covers one or more complete contiguous 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 raster scan slice mode and 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 that references the PPS" and 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 that references the PPS" and 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. As a result, flag 1250 is relevant when rectangular slice mode is applied. When flag 1250 is not present, the value of flag 1250 may be determined to be equal to 1. However, as shown in FIG. 12, signaling of 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 the raster scan slice mode is applied, and flag 1250 ("pps_single_slice_per_subpic_flag") is irrelevant. Therefore, it is not advisable to determine the value of flag 1250 ("pps_single_slice_per_subpic_flag") under the second scenario.

[0169]

[0193] Thus, in some embodiments, when not present, the value of flag 1250 is determined when a rectangular slice mode is applied and is not determined when a raster scan slice mode is applied. Thus, flag 1250 can be properly determined under a rectangular slice mode when not present in a PPS and is not determined under an unrelated raster scan slice mode. Thereby, coding performance and consistency may be improved. For example, the semantics for flag 1250 may be modified to reflect that flag 1250 ("pps_single_slice_per_subpic_flag") equal to 1 specifies that each subpicture includes only one rectangular slice. Flag 1250 ("pps_single_slice_per_subpic_flag") equal to 0 specifies that each subpicture may include 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), when syntax element 1262 ("pps_slice_width_in_tiles_minus1[i]") and syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") are not present, syntax elements 1262, 1264 are determined to be equal to 0. 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 index i ranges from 0 to syntax element 1252 (e.g., the number of slices minus 1). However, for an index i equal to syntax element 1252 ("pps_num_slices_in_pic_minus1"), the values ​​of syntax element 1262 ("pps_slice_width_in_tiles_minus1[i]") and syntax element 1264 ("pps_slice_height_in_tiles_minus1[i]") are not determined to be equal to 0. It is therefore 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 the present 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 units of tile columns, and the value of syntax element 1262 shall be in the range from 0 to (NumTileColumns-1), inclusive. The value of syntax element 1262 is determined to be equal to 0 when it is not present for an index i in the range from 0 to (syntax element 1252-1), inclusive.

[0172]

[0196] Similarly, syntax element 1264+1 specifies the height of the i-th rectangular slice in units of tile rows when syntax element 1266 is equal to 0. The value of syntax element 1264 ranges from 0 to (NumTileRows-1), inclusive. When not present for an index i in the range from 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 FIG. 12, in some embodiments, syntax element 1266 ("pps_num_exp_slices_in_tile[i]") specifies the number of slice heights explicitly given for slices in the tile that contains the i-th slice. If syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is equal to 0, the tile that contains the i-th slice is not divided into multiple slices. If syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is not equal to 0 (e.g., syntax element 1266 ("pps_num_exp_slices_in_tile[i]") is greater than 0), the tile that contains the i-th slice may or may not be divided into multiple slices. Additionally, 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 jth rectangular slice in the tile containing the ith slice in units of CTU rows, for index j in the range 0 to (syntax element 1266 ("pps_num_exp_slices_in_tile[i]") - 1), inclusive. The value of syntax element 1268 ("pps_exp_slice_height_in_ctus_minus1[i][j]") is in the range 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns] - 1), inclusive.

[0174]

[0198] In a scenario where a tile contains only one slice, two different signaling methods may be applied. In a 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 a second method, syntax element 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., the height of the tile-1). Both signaling methods indicate that the tile contains only one slice.

[0175]

[0199] In some embodiments, redundancies in the signaling methods described above are removed by modifying syntax elements and their semantics. An embodiment of the present disclosure provides updated semantics for the PPS syntax. FIG. 30 illustrates an example modified coding syntax table of a portion of a PPS syntax structure 3000 consistent with some embodiments of the present disclosure. As shown in FIG. 30, changes from the previous syntax shown in FIG. 12 are indicated with a highlighted pattern, and the proposed removed syntax is further indicated with strikethrough.

[0176]

[0200] Compared to the SPS syntax shown in FIG. 12, in some embodiments, as shown in FIG. 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 FIG. 30, (syntax element 3066+1) specifies the number of slice heights explicitly given for slices in 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 shall be in the range of 0 to (the height of the corresponding tile, (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns])-2). The value of syntax element 3066 is determined to be equal to 0 when not present.

[0178]

[0202] In the syntax of Figure 30, (syntax element 1268+1) specifies the height of the jth rectangular slice in the tile containing the ith slice in units of CTU rows, for index j ranging from 0 to syntax element 3066 ("pps_num_exp_slices_in_tile_minus1[i]") inclusive. 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 rectangular slices in the tile containing the ith slice with an index greater than syntax element 3066, as specified herein.

[0179]

[0203] 31A and 31B respectively show an example detailed operation of encoding or decoding slice information in a PPS in step 2950 of the method 2900 of FIG. 29, consistent with some embodiments of the present disclosure. When the syntax of FIG. 12 is applied, as shown in FIG. 31A, step 2950 includes step 2952 and step 2954. 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 that includes 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 that includes the i-th slice.

[0180]

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

[0181]

[0205] FIG. 32 illustrates a flowchart of an example video encoding or decoding method 3200 consistent with certain 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 coding performance. When not signaled in the PPS, the value of the PPS syntax element or flag may be determined or assigned accordingly. 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 an apparatus (e.g., apparatus 400 of FIG. 4) for encoding or transcoding a video sequence or for decoding a bitstream to reconstruct a video stream. For example, one or more processors (e.g., processor 402 of FIG. 4) may perform method 3200.

[0182]

[0206] In step 3205, the device is configured to code or decode a PPS flag 1210 ("pps_no_pic_partition_flag") for indicating in a PPS whether a picture referencing the PPS is partitioned. As mentioned above, in some embodiments, for pictures in the same CLVS, different PPSs may independently signal PPS flags 1210 with different values. For example, the device may code or decode a first flag in a first PPS indicating whether a first picture referencing the first PPS is partitioned into tiles or slices, and code or decode a second flag in a second PPS indicating whether a second picture referencing the second PPS is partitioned, where the first flag and the second flag have different values.

[0183]

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

[0184]

[0208] After the value of flag 1250 is determined or encoded / decoded in step 3230 or step 3225, in step 3240, when 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 value equal to (the number of rectangular slices in the picture minus 2), the device determines that syntax element 1262 is 0. Syntax element 1262 is a picture parameter related to the width of the i-th rectangular slice for index i. In some embodiments, the value of syntax element 1262 ranges from 0 to (the number of columns of the corresponding tile (NumTileColumns) minus 1).

[0185]

[0209] In step 3250, when 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 value equal to the number of rectangular slices in the picture minus 2, the device determines the value of syntax element 1264. Syntax element 1264 is a picture parameter related to the height of the i-th rectangular slice for index i. In some embodiments, the value of syntax element 1264 ranges from 0 to the number of columns of the corresponding tile (e.g., NumTileRows) minus 1, inclusive. As described in the above embodiments, syntax element 1264 for the i-th rectangular slice, when not present, may be determined to be 0 or equal to the value of 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 ranges from 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]−2). Stated another way, syntax element 1268 is an encoded or decoded picture parameter that has an upper limit value of (the height of the corresponding tile−2).

[0187]

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

[0188]

[0212] As mentioned above, in some embodiments, for rectangular slices in a tile, syntax element 1266 specifies the number of slice heights explicitly given for slices in the tile that contains 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 that contains the i-th slice in units of CTU rows, for index j ranging from 0 to (syntax element 1266-1), inclusive. The value of syntax element 1268 ranges from 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-1), inclusive.

[0189]

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

[0190]

[0214] An embodiment of the present disclosure provides 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] 12, the semantics for syntax element 1268 may be modified to reflect that the value of syntax element 1268 ranges from 0 to (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-the value of syntax element 1266). In other words, the upper limit value of syntax element 1268 is (the height of the corresponding tile-the number of slice heights explicitly given for the slices in the corresponding tile).

[0192]

[0216] When combined with the embodiment shown in FIG. 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] - the value of syntax element 3066 - 1), inclusive.

[0193]

[0217] In combination with the embodiment of reducing 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 that selects the greater 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 in the range of 0 or greater and (RowHeight[SliceTopLeftTileIdx[i] / NumTileColumns]-max(pps_num_exp_slices_in_tile[i],2)) or less. In other words, the upper limit value of syntax element 1268 is the lesser 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] 33 illustrates an example pseudocode including updated derivations for variables NumCtusInSlice, SliceTopLeftTileIdx, CtbAddrInSlice, and NumSlicesInTile, in accordance with some embodiments of the present disclosure. As illustrated in FIG. 33, changes from the previous VVC are indicated with highlighted patterns, and suggested removed syntax is further indicated with strikethrough.

[0195]

[0219] 34 illustrates an example pseudocode including an updated derivation of variables NumCtusInSlice and CtbAddrInSlice according to some embodiments of the present disclosure. As illustrated in FIG. 34, changes from the previous VVC are shown in italics, and the proposed removed syntax is further shown in strikethrough. In the pseudocode illustrated in FIG. 34, an error in the derivation of NumCtusInSlice[i] and CtbAddrInSlice[i][j] and one redundant line in the previous VVC pseudocode have been corrected.

[0196]

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

[0197]

[0221] Although various embodiments of the present disclosure are described with respect to the current VVC standard, it should be understood that the various embodiments are applicable to other video coding techniques.

[0198]

[0222] The embodiments may be further described using the following clauses. 1. A method for encoding or decoding video, comprising: encoding or decoding a corresponding first PPS flag in a plurality of picture parameter sets (PPS) associated with a picture of a coded layer video sequence (CLVS), the PPS flag indicating whether the picture can be partitioned into a plurality of tiles or slices; A method, in which in a first PPS, a corresponding first PPS flag having a first value indicates that a first picture of a 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 a second picture of a CLVS is partitionable. 2. A method for encoding or decoding video, comprising: determining whether a number of tiles of the partitioned picture is greater than a threshold, the threshold being greater than 1; encoding or decoding a second PPS flag associated with a slice mode applied to the partitioned picture in response to the number of tiles of the partitioned picture being greater than a threshold; A method comprising: 3. Encoding or decoding a second PPS flag, The method of any one of clauses 1 to 2, further comprising: 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 of clause 3, further comprising encoding or decoding one or more syntax elements that specify slice information in the PPS when a rectangular slice mode is applied to a partitioned picture that references a PPS. 5. A method for encoding or decoding a video, comprising: determining whether a picture is partitioned into a plurality of tiles or slices; In response to determining that the picture can be partitioned into a plurality of tiles or slices, encoding or decoding a first flag in a picture parameter set (PPS) associated with a 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 for 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 a raster scan slice mode, a picture is partitioned into a number of raster scan slices, any one of which includes a sequence of one or more complete tiles in a tile raster scan of the picture; The method of any of clauses 3 to 5, wherein in a 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 a coding tree unit of a tile. 7. The method of claim 5 or 6, further comprising encoding or decoding a first picture parameter specifying (the number of slice heights given for slices in a corresponding tile minus 1), the first picture parameter being equal to 0 if the corresponding tile contains a single slice. 8. The method according to clause 7, wherein the value of the first picture parameter is in the range from 0 to (the height of the corresponding tile minus 2). 9. The method of any of clauses 5 to 8, further comprising encoding or decoding a third picture parameter specifying the number of slice heights given for slices in a corresponding tile, the third picture parameter being equal to 0 if the corresponding tile contains a single slice. 10. 10. The method of claim 9, further comprising encoding or decoding a second picture parameter specifying (a height of a corresponding rectangular slice in a corresponding tile minus 1). 11. The method according to clause 10, wherein the upper limit value of the second picture parameter is (the height of the corresponding tile -2). 12. The method of claim 10, wherein the upper limit value 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 to 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 method according to clause 10, wherein the fifth picture parameter indicates (the number of slice heights given for the slices in the corresponding tile minus 1). 14. The method according to clause 10, wherein the upper limit value 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). 15. A method for encoding or decoding video, comprising: encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with at least one picture of a coded layer video sequence (CLVS) indicating whether the associated picture can be partitioned into multiple tiles or slices, wherein the first PPS flag equal to a first value indicates that the associated picture is not partitioned and the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable; skipping, when the first PPS flag is equal to a first value, encoding or decoding, in the PPS, a second PPS flag indicating whether each sub-picture of the associated picture includes a single rectangular slice, and determining a value of the second PPS flag equal to a third value, where the second PPS flag equal to the third value indicates that each sub-picture of the associated picture includes a single rectangular slice; A method comprising: 16. A method for encoding or decoding video, comprising: For index i, encoding or decoding a first picture parameter associated with a width of an i-th rectangular slice in a picture parameter set (PPS) associated with at least one picture of a coded layered video sequence (CLVS); determining that the first picture parameter is 0 when the first picture parameter is not present in the PPS; The method, where index i ranges from 0 to an upper value equal to (the number of rectangular slices in the picture minus 2). 17. encoding or decoding a second picture parameter associated with a height of the i-th rectangular slice for index i; determining, when the second picture parameter is not present in the PPS for index i, that the second picture parameter is equal to 0 or to a value of a third picture parameter associated with a height of the (i-1)th rectangular slice; 17. The method of claim 16, further comprising: 18. A method for encoding or decoding video, comprising: encoding or decoding a first SPS flag in a sequence parameter set (SPS) of a bitstream, the SPS flag indicating whether one or more pictures in a coded layered video sequence (CLVS) that references the SPS are partitioned into multiple tiles or slices; encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with the SPS, the first PPS flag being equal to a first SPS flag for indicating whether a picture referencing the PPS is partitioned; A method comprising: 19. The method of claim 18, further comprising: skipping encoding or decoding a second SPS flag in the SPS in response to the first SPS flag indicating that one or more pictures are not partitioned, the second SPS flag indicating whether sub-picture information is present for a CLVS that references the SPS. 20. The method of claim 18 or 19, further comprising: skipping encoding or decoding a first SPS sequence parameter associated with a number of sub-pictures in each picture in the CLVS that references the SPS in response to the first SPS flag indicating that one or more pictures are not partitioned. 21. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: In a plurality of picture parameter sets (PPS) associated with a picture of a coded layered video sequence (CLVS), encoding or decoding a corresponding first PPS flag indicating whether the picture can be partitioned into a plurality of tiles or slices. configured to execute instructions to cause An apparatus, wherein in a first PPS, a corresponding first PPS flag having a first value indicates that a first picture of a 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 a second picture of a CLVS is partitionable. 22. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: determining whether a number of tiles of the partitioned picture is greater than a threshold, the threshold being greater than 1; In response to the number of tiles of the partitioned picture being greater than a threshold, encoding or decoding a second PPS flag associated with a slice mode applied to the partitioned picture; An apparatus configured to execute instructions to cause 23. One or more processors may include: encoding or decoding a second PPS flag having a third value when a raster scan slice mode is applied to the partitioned picture that references the 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 the partitioned picture that references the PPS. 23. The apparatus of claim 21 or 22, configured to execute instructions to cause the encoding or decoding of the second PPS flag by: 24. The one or more processors further include: encoding or decoding one or more syntax elements that specify slice information in a PPS when a rectangular slice mode is applied to a partitioned picture that references a PPS 24. The apparatus of claim 23, configured to execute instructions to cause 25. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: determining whether a picture is partitioned into a plurality of tiles or slices; In response to determining that the picture can be partitioned into a plurality of tiles or slices, encoding or decoding a first flag in a picture parameter set (PPS) associated with a slice mode applied to the picture that references the PPS; encoding or decoding a first flag having a first value when a raster scan slice mode is applied to partition the picture, or encoding or decoding the first flag having a second value different from the first value when a rectangular slice mode is applied to partition the picture; An apparatus configured to execute instructions to cause 26. In a raster scan slice mode, a picture is partitioned into multiple raster scan slices, any one of which includes a sequence of one or more complete tiles in a tile raster scan of the picture; The apparatus described in clause 25, wherein in a 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 a coding tree unit of a tile. 27. The one or more processors further include: Encoding or decoding a first picture parameter that specifies (the number of slice heights given for the slices in the corresponding tile minus 1) 27. The apparatus of claim 25 or 26, configured to execute instructions to cause a first picture parameter to be equal to 0 if the corresponding tile contains a single slice. 28. The apparatus of clause 27, wherein the value of the first picture parameter is in the range from 0 to (the height of the corresponding tile minus 2). 29. The one or more processors further include: encoding or decoding a third picture parameter specifying a given slice height number for slices within a corresponding tile; 29. The apparatus of any of clauses 25 to 28, further configured to execute instructions to cause a third picture parameter to be equal to 0 if the corresponding tile contains a single slice. 30. The one or more processors further include: encoding or decoding a second picture parameter specifying (the height of the corresponding rectangular slice in the corresponding tile minus 1); 30. An apparatus as described in clause 29, configured to execute instructions to cause 31. The apparatus of clause 30, wherein an upper limit value of the second picture parameter is (height of the corresponding tile -2). 32. The apparatus of clause 30, wherein an upper limit value 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 in the corresponding tile. 33. The upper limit value of the second picture parameter is (the height of the corresponding tile-the fifth parameter-1); 31. The apparatus of claim 30, wherein the fifth picture parameter indicates (a number of slice heights given for slices in a corresponding tile minus 1). 34. The apparatus of clause 30, wherein the upper limit value 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. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: encoding or decoding a first PPS flag in a Picture Parameter Set (PPS) associated with at least one picture of a Coded Layer Video Sequence (CLVS) indicating whether the associated picture can be partitioned into multiple tiles or slices, wherein the first PPS flag equal to a first value indicates that the associated picture is not partitioned 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 a first value, skip encoding or decoding a second PPS flag indicating whether each sub-picture of the associated picture includes a single rectangular slice in the PPS, and determine a value of the second PPS flag equal to a third value, where the second PPS flag equal to the third value indicates that each sub-picture of the associated picture includes a single rectangular slice; An apparatus configured to execute instructions to cause 36. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: For index i, encoding or decoding a first picture parameter associated with a width of the i-th rectangle in a picture parameter set (PPS) associated with at least one picture of a coded layered video sequence (CLVS); determining that the first picture parameter is 0 when the first picture parameter is not present in the PPS; 23. An apparatus configured to execute instructions to cause a pixel to be shifted in a pixel direction by a pixel, the pixel being shifted in a pixel direction by a pixel, the pixel being shifted in a pixel direction by a pixel, 37. The one or more processors further include: encoding or decoding a second picture parameter associated with a height of the i-th rectangular slice for index i; determining, when the second picture parameter is not present in the PPS for index i, that the second picture parameter is equal to 0 or to a value of a third picture parameter associated with a height of the (i-1)th rectangular slice; 37. An apparatus as described in clause 36 and configured to execute instructions to cause 38. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: encoding or decoding a first SPS flag in a sequence parameter set (SPS) of a bitstream, the SPS flag indicating whether one or more pictures in a coded layered video sequence (CLVS) that references the SPS are partitioned into multiple tiles or slices; encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with the SPS, the first PPS flag being equal to a first SPS flag for indicating whether a picture referencing the PPS is partitioned; An apparatus configured to execute instructions to cause 39. The one or more processors further include: skipping encoding or decoding a second SPS flag in the SPS in response to the first SPS flag indicating that the one or more pictures are not partitioned. 39. The apparatus of claim 38, configured to execute instructions to cause a second SPS flag to indicate whether sub-picture information is present for a CLVS that references the SPS. 40. The one or more processors further include: skipping encoding or decoding a first SPS sequence parameter associated with a number of sub-pictures in each picture in the CLVS that references the SPS in response to the first SPS flag indicating that the one or more pictures are not partitioned. 39. An apparatus as described in clause 38 or clause 39 configured to execute instructions to cause 41. A non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations being: encoding or decoding a corresponding first PPS flag in a plurality of picture parameter sets (PPS) associated with a picture of a coded layer video sequence (CLVS), the PPS flag indicating whether the picture can be partitioned into a plurality of tiles or slices; A non-transitory computer-readable storage medium, in which a corresponding first PPS flag having a first value in a first PPS indicates that a first picture of a 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 a second picture of the CLVS is partitionable. 42. A non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations being: determining whether a number of tiles of the partitioned picture is greater than a threshold, the threshold being greater than 1; encoding or decoding a second PPS flag associated with a slice mode applied to the partitioned picture in response to the number of tiles of the partitioned picture being greater than a threshold; A non-transitory computer readable storage medium comprising: 43. A set of instructions executable by one or more processors of a device comprising: encoding or decoding a second PPS flag having a third value when a raster scan slice mode is applied to the partitioned picture that references the 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 the partitioned picture that references the PPS. 43. The non-transitory computer-readable storage medium of claim 41 or 42, further causing the device to encode or decode the second PPS flag by: 44. A set of instructions is encoding or decoding one or more syntax elements that specify slice information in a PPS when a rectangular slice mode is applied to a partitioned picture that references a PPS 44. The non-transitory computer-readable storage medium of claim 43, executable by one or more processors of the device to further cause the device to perform operations including: 45. A non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations being: determining whether a picture is partitioned into a plurality of tiles or slices; In response to determining that the picture can be partitioned into a plurality of tiles or slices, encoding or decoding a first flag in a picture parameter set (PPS) associated with a slice mode applied to the picture referencing the PPS; A non-transitory computer-readable storage medium that encodes or decodes a first flag having a first value when a raster scan slicing 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 slicing mode is applied to partition a picture. 46. In a raster scan slice mode, a picture is partitioned into a number of raster scan slices, any one of which includes a sequence of one or more complete tiles in a tile raster scan of the picture; The non-transitory computer-readable storage medium of clause 45, wherein in a 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 a coding tree unit of a tile. 47. A set of instructions executable by one or more processors of a device comprising: encoding or decoding a first picture parameter specifying (a given number of slice heights for slices in a corresponding tile minus 1), where the first picture parameter is equal to 0 if the corresponding tile contains a single slice; The non-transitory computer-readable storage medium of claim 45 or 46, further causing a device to perform operations including: 48. The non-transitory computer-readable storage medium of clause 47, wherein the value of the first picture parameter is in the range from 0 to (the height of the corresponding tile - 2). 49. A set of instructions executable by one or more processors of a device comprising: encoding or decoding a third picture parameter specifying a number of given slice heights for slices in a corresponding tile, the third picture parameter being equal to 0 if the corresponding tile contains a single slice; 49. The non-transitory computer-readable storage medium of any of clauses 45 to 48, further causing a device to perform operations including: 50. A set of instructions executable by one or more processors of a device comprising: encoding or decoding a second picture parameter specifying (the height of the corresponding rectangular slice in the corresponding tile minus 1); 50. The non-transitory computer-readable storage medium of clause 49, further causing the device to perform operations including: 51. The non-transitory computer-readable storage medium of clause 50, wherein an upper limit value of the second picture parameter is (height of the corresponding tile - 2). 52. The non-transitory computer-readable storage medium of clause 50, wherein an upper limit value 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 in the corresponding tile. 53. The upper limit value of the second picture parameter is (the height of the corresponding tile-the fifth parameter-1); The non-transitory computer-readable storage medium of claim 50, wherein the fifth picture parameter indicates (the number of slice heights given for slices in a corresponding tile minus 1). 54. The non-transitory computer-readable storage medium of clause 50, wherein the upper limit value 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-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations being: encoding or decoding a first PPS flag in a Picture Parameter Set (PPS) associated with at least one picture of a Coded Layer Video Sequence (CLVS) indicating whether the associated picture can be partitioned into multiple tiles or slices, wherein the first PPS flag equal to a first value indicates that the associated picture is not partitioned 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 a first value, skip encoding or decoding, in the PPS, a second PPS flag indicating whether each sub-picture of the associated picture includes a single rectangular slice, and determine a value of the second PPS flag equal to a third value, where the second PPS flag equal to the third value indicates that each sub-picture of the associated picture includes a single rectangular slice; A non-transitory computer readable storage medium comprising: 56. A non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations including: For index i, encoding or decoding a first picture parameter associated with a width of an i-th rectangular slice in a picture parameter set (PPS) associated with at least one picture of a coded layered video sequence (CLVS); determining that the first picture parameter is 0 when the first picture parameter is not present in the PPS; A non-transitory computer-readable storage medium, wherein index i ranges from 0 to an upper value equal to (the number of rectangular slices in the picture minus 2). 57. A set of instructions executable by one or more processors of a device comprising: encoding or decoding a second picture parameter associated with a height of the i-th rectangular slice for index i; determining, when the second picture parameter is not present in the PPS for index i, that the second picture parameter is equal to 0 or to a value of a third picture parameter associated with a height of the (i-1)th rectangular slice; 57. The non-transitory computer-readable storage medium of clause 56, further causing the device to perform operations including: 58. A non-transitory computer-readable storage medium storing a set of instructions, the set of instructions being executable by one or more processors of a device to cause the device to perform operations, the operations being: encoding or decoding a first SPS flag in a sequence parameter set (SPS) of a bitstream, the SPS flag indicating whether one or more pictures in a coded layered video sequence (CLVS) that references the SPS are partitioned into multiple tiles or slices; encoding or decoding a first PPS flag in a picture parameter set (PPS) associated with the SPS, the first PPS flag being equal to a first SPS flag for indicating whether a picture referencing the PPS is partitioned; A non-transitory computer readable storage medium comprising: 59. A set of instructions executable by one or more processors of a device comprising: skipping encoding or decoding a second SPS flag in the SPS in response to the first SPS flag indicating that one or more pictures are not partitioned, the second SPS flag indicating whether sub-picture information exists for a CLVS that references the SPS; 59. The non-transitory computer-readable storage medium of clause 58, further causing the device to perform operations including: 60. A set of instructions executable by one or more processors of a device comprising: skipping encoding or decoding a first SPS sequence parameter associated with a number of sub-pictures in each picture in the CLVS that references the SPS in response to the first SPS flag indicating that the one or more pictures are not partitioned. The non-transitory computer-readable storage medium of claim 58 or 59, further causing a device to perform operations including:

[0199]

[0223] In some embodiments, a non-transitory computer-readable storage medium is also provided that includes instructions, which may be executed by an apparatus (such as the disclosed encoder and decoder) to perform the above-described method. Typical non-transitory media include, for example, floppy disks, flexible disks, hard disks, solid state drives, magnetic tapes or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media with a pattern of holes, RAM, PROMs and EPROMs, FLASH-EPROMs or any other flash memory, NVRAM, caches, registers, any other memory chips or cartridges, and networked versions of the same. An apparatus may include one or more processors (CPUs), input / output interfaces, network interfaces, and / or memory.

[0200]

[0224] It should be noted that relative terms such as "first" and "second" herein are used merely to distinguish one entity or operation from another and do not require or imply any actual relationship or order between those entities or operations. Furthermore, the terms "comprise," "have," "contain," and "include," as well as other similar forms, are intended to be equivalent in meaning and are non-limiting in that the items following any one of these terms are not intended to be an exhaustive listing of such items or to be limited to only the items listed.

[0201]

[0225] As used herein, unless otherwise specified, the word "or" includes all possible combinations unless impracticable. For example, if a database is stated to include A or B, the database can include A, B, A, and B, unless otherwise specified or impracticable. As a second example, if a database is stated to include A, B, or C, the database can include A, B, C, A and B, A and C, B and C, A and B and C, unless otherwise specified or impracticable.

[0202]

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

[0203]

[0227] In the above specification, the embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. Certain adaptations and modifications to the described embodiments may be made. Other embodiments may become apparent to those skilled in the art from consideration of the specification and practice of the disclosure disclosed herein. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the appended claims. The order of steps depicted in the figures is for illustrative purposes only and is not intended to be limited to the particular order of steps. Thus, one skilled in the art can appreciate that the steps may be performed in different orders while implementing the same method.

[0204]

[0228] Although illustrative embodiments have been disclosed in the drawings and herein, many variations and modifications thereto may be made, and therefore, although specific terms have been employed, they are used in a generic and descriptive sense only and not for purposes of limitation.

Claims

1. 1. A method for encoding or decoding video, comprising the steps of: encoding or decoding a corresponding first PPS flag in a plurality of picture parameter sets (PPS) associated with a picture of a coded layer video sequence (CLVS), the PPS flag indicating whether the picture can be partitioned into a plurality of tiles or slices; A method, in which in a first PPS, a corresponding first PPS flag having a first value indicates that a 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 a second picture of the CLVS is partitionable.

2. determining whether a number of tiles in the partitioned picture is greater than a threshold, the threshold being greater than 1; encoding or decoding a second PPS flag associated with a slice mode applied to the partitioned picture in response to the number of tiles of the partitioned picture being greater than the threshold; The method of claim 1 further comprising:

3. The encoding or decoding of the second PPS flag comprises:

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

4. The method of 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. An apparatus comprising: A memory configured to store instructions; and one or more processors, the one or more processors causing the apparatus to: determining whether a picture is partitioned into a plurality of tiles or slices; In response to determining that the picture can be partitioned into the plurality of tiles or slices, encoding or decoding a first flag in a Picture Parameter Set (PPS) associated with a slice mode applied to the picture referencing the PPS; encoding or decoding the first flag having a first value when a raster scan slice mode is applied to partition the picture, or encoding or decoding the first flag having a second value different from the first value when a rectangular slice mode is applied to partition the picture; 4. An apparatus configured to execute the instructions to cause

6. In the raster scan slice mode, the picture is partitioned into a number of raster scan slices, any one of the raster scan slices comprising a sequence of one or more complete tiles in a tile raster scan of the picture; 6. The apparatus of claim 5, wherein in the rectangular slice mode, the picture is partitioned into a plurality of rectangular slices, one of the rectangular slices including one or more tiles covering a rectangular region of the picture, or one of the rectangular slices covering one or more consecutive rows of a coding tree unit of a tile.

7. The one or more processors further configure the apparatus to: Encoding or decoding a first picture parameter specifying (a given number of slice heights for slices in a corresponding tile minus 1) and wherein the first picture parameter is equal to 0 if the corresponding tile includes a single slice.

8. The apparatus of claim 7 , wherein the value of the first picture parameter is in the range from 0 to (the height of the corresponding tile−2).

9. The one or more processors further configure the apparatus to: encoding or decoding a third picture parameter specifying the number of given slice heights for slices within a corresponding tile; and wherein the third picture parameter is equal to 0 if the corresponding tile includes a single slice.

10. The one or more processors further configure the apparatus to: encoding or decoding a second picture parameter specifying (the height of a corresponding rectangular slice in the corresponding tile minus 1); 10. The apparatus of claim 9, configured to execute the instructions to cause:

11. The apparatus of claim 10, wherein an upper limit value of the second picture parameter is (the height of the corresponding tile -2).

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

13. the upper limit value of the second picture parameter is (the height of the corresponding tile−the fifth parameter−1); The apparatus of claim 10, wherein the fifth picture parameter indicates (the number of slice heights given for a slice in the corresponding tile minus 1).

14. 11. The apparatus of claim 10, wherein an upper limit value 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-transitory computer-readable storage medium storing a set of instructions, the set of instructions executable by one or more processors of a device to cause the device to perform operations, the operations comprising: encoding or decoding a first PPS flag in a Picture Parameter Set (PPS) associated with at least one picture of a Coded Layer Video Sequence (CLVS), the first PPS flag indicating whether the associated picture can be partitioned into multiple tiles or slices, wherein the first PPS flag equal to a first value indicates that the associated picture is not partitioned or the first PPS flag equal to a second value different from the first value indicates that the associated picture is partitionable; skipping, when the first PPS flag is equal to the first value, encoding or decoding, in the PPS, a second PPS flag indicating whether each sub-picture of the associated picture includes a single rectangular slice, and determining a 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 includes a single rectangular slice; A non-transitory computer readable storage medium comprising:

16. The set of instructions: For index i, encoding or decoding a first picture parameter associated with a width of the i-th rectangular slice in a picture parameter set (PPS) associated with at least one picture of a coded layered video sequence (CLVS); determining that the first picture parameter is 0 when the first picture parameter is not present in the PPS; and wherein the one or more processors of the device are executable to cause the device to further perform operations including:

16. The non-transitory computer-readable storage medium of claim 15, wherein the index i ranges from 0 to an upper value equal to (a number of rectangular slices in the picture minus 2).

17. The set of instructions: encoding or decoding, for said index i, a second picture parameter associated with a height of said i-th rectangular slice; determining, when the second picture parameter is not present in the PPS for the index i, that the second picture parameter is 0 or equal to the value of a third picture parameter associated with the height of an (i-1)th rectangular slice; 20. The non-transitory computer-readable storage medium of claim 16, executable by the one or more processors of the device to cause the device to further perform operations including:

18. The set of instructions: encoding or decoding a first SPS flag in a sequence parameter set (SPS) of a bitstream, the SPS flag indicating whether one or more pictures in the CLVS that reference the SPS are partitioned into the tiles or slices; encoding or decoding a first PPS flag equal to the first SPS flag for indicating whether the picture referencing the PPS is partitioned in the PPS associated with the SPS; 20. The non-transitory computer-readable storage medium of claim 15, executable by the one or more processors of the device to cause the device to further perform operations including:

19. The set of instructions: skipping encoding or decoding a second SPS flag in the SPS in response to the first SPS flag indicating that the one or more pictures are not partitioned.

20. The non-transitory computer-readable storage medium of claim 18, executable by the one or more processors of the device to further cause the device to perform operations including:

20. The set of instructions: skipping encoding or decoding a first SPS sequence parameter associated with a number of sub-pictures in each picture in the CLVS that reference the SPS in response to the first SPS flag indicating that the one or more pictures are not partitioned.

20. The non-transitory computer-readable storage medium of claim 18, executable by the one or more processors of the device to cause the device to further perform operations including:

Images