OA20342A

OA20342A - Video coding comprising uniform tile split with remainder.

Info

Publication number: OA20342A
Application number: OA1202000399
Authority: OA
Inventors: Mitra DAMGHANIAN; Martin Pettersson; Rickard Sjöberg
Original assignee: Telefonaktiebolaget Lm Ericsson
Priority date: 2019-01-16
Filing date: 2020-01-16
Publication date: 2022-06-02

Abstract

Method for decoding a picture, comprising: decoding information that the picture is partitioned into more than one segment based on one or more syntax elements in a bitstream; decoding information that the spatial segmentation is uniform based on the one or more syntax elements; determining a segment unit size based on the one or more syntax elements or based on a predefined segment unit size; decoding a first value indicating a segment width from one or more code words in the bitstream; decoding a second value indicating a segment height from the one or more code words; deriving segment column widths based on a picture width in number of segment units and the first value; deriving segment row heights based on a picture height in number of segment units and the second value; deriving a spatial location for a current block based on the derived segment column widths and the derived segment heights; and decoding the current block based on the derived spatial location.

Description

VIDEO CODING COMPRISING UNIFORM TILE SPLIT WITH REMAINDER

TECHNICAL FIELD

This disclosure relates to High Efficiency Video Coding (HEVC) and Versatile Video Coding (VVC).

BACKGROUND

HEVC and the next génération video coding

High Efficiency Video Coding (HEVC), a.k.a. H.265, is a block-based video codée standaidized by ITU-T and MPEG that utilizes both temporal and spatial prédiction. Spatial prédiction is achieved using intra (I) prédiction from within the current picture. Temporal prédiction is achieved using inter (P) or bi-directional inter (B) prédiction on block level from previously decoded reference pictures. The différence between the original pixel data and the predicted pixel data, lefened to as the residual, is transformed into the frequency domain, quantized and then entropy coded before transmitted together with necessary prédiction parameters such as prédiction mode and motion vectors, also entropy coded. By quantizing the transformed residuals, a tradeoff between bitrate and quality of the video may be controlled. The level of quantization is detennined by a quantization parameter (QP). The décoder performs entropy decoding, inverse quantization, and inverse transformation to obtain the residual. The décoder then then adds the residual to an intra prédiction or an inter prédiction to reconstruct a picture.

MPEG and ITU-T is working on the successor to HEVC within the Joint Video Exploratory Team (JVET). The name of this video codée under development is VCC.

Slices

The concept of slices in HEVC divides the picture into independently coded slices, where each slice is read in raster Scan order in units of coding tree units (CTUs). Different coding types could be used for slices of the same picture, i.e. a slice could either be an Ι-slice, P-slice or Bslice. The main purpose of slices is to enable resynchronization in case of data loss.

Tiles

The HEVC video coding standard includes a tool called tiles that divides a picture into rectangular spatially independent régions. Using tiles, a picture in HEVC can be partitioned into rows and columns of samples where a tile is an intersection of a row and a column. The tiles in HEVC are always aligned with CTU boundaries.

FIG. 1 shows an example of a tile partitioning using 4 tile rows and 5 tile columns resulting in a total of 20 tiles for the picture.

The tile structure is signaled in the picture parameter set (PPS) by specifying the thicknesses ofthe rows and the widths of the columns. Individual rows and columns can hâve different sizes, but the partitioning always span across the entire picture, from left to right and top to bottom respectively. There is no decoding dependency between tiles of the same picture. This includes intra prédiction, context sélection for entropy coding and motion vector prédiction. One exception is that in-loop filtering dependencies are generally allowed between tiles.

The PPS syntax used for specifying the tile structure in HEVC is listed Table 1 below. A flag, e.g., tiles_enabled_flag, indicates whether tiles are used or not. If the flag is set, the number of tiles columns and rows are specified. The uniform_spacing_flag is a flag specifying whether the column widths and row heights are explicitly signaled or whether a pre-defined method to space the tile borders evenly should be used. If explicit signaling is indicated, the column widths are signaled one-by-one followed by the row heights. Such column widths and row heights are signaled in CTU units. The loop_filter_across_tiles_enabled_flag flag spécifiés whether in-loop filters across tile boundaries are tumed on or off for ail tile boundaries in the picture.

Table 1. Exemplary tile syntax in HEVC

pic_parameter_set_rbsp( ) {	Descriptor
...
tilesenabledflag	u(l)
...
if( tiles_enabled_flag ) {
numtilecolumnsminusl	ue(v)
numtilerowsminusl	ue(v)
uniformspacingflag	u(l)
if( !uniform_spacing_flag ) {
for( i = 0; i < num_tile_columns_minus 1 ; i++)
column_width_minusl[ i ]	ue(v)
for( i = 0; i < num tile rows minus 1; i++ )
row_height_minusl[ i ]	ue(v) J

____L
loopfïlteracross tiles enabled flag	u(l)
}
...

The semantics for specifying the tile structure in HEVC are explained in further detail below:

tilesenabledflag equal to 1 spécifiés that there is more than one tile in each picture referring to the PPS. tiles_enabled_flag equal to 0 spécifiés that there is only one tile in each picture referring to the PPS.

num_tile_columns_minusl plus 1 spécifiés the number of tile columns partitioning the picture. num_tile_columns_minus 1 shah be in the range of 0 to PicWidthlnCtbsY - 1, inclusive. When not présent, the value of num_tile_columns_minus 1 is inferred to be equal to 0.

numtilerowsminusl plus 1 spécifiés the number of tile rows partitioning the picture. num_tile_rows_minus 1 shall be in the range of 0 to PicHeightlnCtbsY - 1, inclusive. When not présent, the value of num_tile_rows_minus 1 is inferred to be equal to 0.

When tiles_enabled_flag is equal to 1, num_tile_columns minus 1 and num_tile_rows_minusl shall not be both equal to 0.

uniform spacing flag equal to 1 spécifiés that tile column boundaries and likewise tile row boundaries are distributed uniformly across the picture. uniform_spacing_flag equal to 0 spécifiés that tile column boundaries and likewise tile row boundaries are not distributed uniformly across the picture but signalled explicitly using the syntax éléments column_width_minus 1 [ i ] and row_height_minus 1 [ i ]. When not présent, the value of uniform_spacing_flag is inferred to be equal to 1.

column_width_minusl[ i ] plus 1 spécifiés the width of the i-th tile column in units ofCTBs.

row_height_minusl[ i ] plus 1 spécifiés the height of the i-th tile row in units of CTBs.

loopfilteracrosstilesenabledflag equal to 1 spécifiés that in-loop filtering operations may be performed across tile boundaries in pictures referring to the PPS.

loop_filter_across_tiles_enabled flag equal to 0 spécifiés that in-loop filtering operations are not performed across tile boundaries in pictures referring to the PPS. The in-loop filtering operations include the deblocking filter and sample adaptive offset filter operations. When not présent, the value of loop_filter_across_tiles_enabled_flag is inferred to be equal to 1.

VVC is expected not to use traditional slices as in HEVC. Instead, tiles are expected to play a larger rôle in VVC due to increased demand for spatial random access from video services including VR streaming.

The concept of tile groups was agreed to be included in the current VVC draft at the last JVET meeting. A tile group is used to group multiple tiles to reduce the overhead of each tile.

A tile group in the current VVC draft may be rectangular and consist of MxN tiles, where M is the number of tiles vertically and N the number of tiles horizontally.

Uniform tile partitioning in HEVC

HEVC tile partitioning requires that ail tile boundaries are aligned with the CTU grid. It means that ail tiles consist of full CTUs and the only incomplète CTUs allowed in the tiles are the ones located in the right or bottom edge of the picture. In HEVC, the syntax element uniform_spacing_flag equal to 1 spécifiés that tile column boundaries and likewise tile row boundaries are distributed uniformly across the picture. However, this uniformity is limited by the CTU gianulanty. In HEVC, the list colWidth[ i ] for i ranging from 0 to num tile columns minus 1, inclusive, spécifiés the width of the i-th tile column in units of coding tree blocks (CTBs) and is derived as the following équation (A):

if( uniform_spacing_flag ) for( i = 0; i <= numtilecolumnsminusl ; i++ ) colWidth[ i ] = ( ( i + 1 ) * PicWidthlnCtbsY ) / ( num_tile_columns_minus 1 + 1 ) ( i * PicWidthlnCtbsY ) / ( num tile columns minusl + 1 )

A similar équation (B) is used for determining the heights of the tile rows (rowHeight[ i ]):

if( uniform_spacing_flag ) for( j = 0; j <= num_tile_rows_minus 1 ; j++ ) rowHeightf j ] = ( ( j + 1 ) * PicHeightlnCtbsY ) / ( num_tile_rows_ minus 1 + 1 ) ( j * PicHeightlnCtbsY ) / ( num tile rows minus 1 + 1 )

Flexible tile splitting

Flexible tile splitting, introduced in JVET-K0155, followed by JVET-L0359, provides the functionality to split a picture into partitioning tiles where the width or height of each tile is a multiple of a unit size finer than the CTU size. Flexible tile splitting allows the use of incomplète CTUs in the right and bottom edge of every tile (rather than only the right and bottom edge of the picture). FIGS. 2A-2B provides examples for a 2x2 tile segmentation using flexible tile splitting as in JVET-L0359 where the tile unit size is a quarter of the CTU size.

In FIGS. 2A-2B, tiles are shown by thick black lines and CTUs are shown by thin black lines. FIG. 2A shows the HEVC method with 20 CTUs in the picture. FIG. 2B shows the proposed method in JVET-L0359, with 24 CTUs in the picture and the tile unit size equal to a 10 quarter of the CTU size, shown by dashed gray lines.

Flexible tile splitting may be useful for applications such as load balancing and 360° video with face sizes desired not to be a multiple of the CTU size.

The syntax and semantics from JVET-L0359 relevant to the current disclosure are listed below, where the italicized portions are the added text proposed in L0359.

pic_parameter_set_rbsp( ) {	Descriptor
pps_pic_parameter_set_id	ue(v)
pps_seq_parameter_set_id	ue(v)
transform_skip_enabled_flag	u(l)
tiles_enabled_flag	u(l)
if( tiles_enabled_flag ) {
tile_un it_size_idc	ue(v)
num_tile_columns_minus 1	ue(v)
num_tile_rows_minus 1	ue(v)
uniform_spacing_flag	u(l)
if( !uniform_spacing_flag ) {
for( i = 0; i < num_tile_columns_minus 1 ; i++ )
column_width_minus 1 [ i ]	ue(v)
for( i = 0; i < num_tile_rows_minus 1 ; i++ )
row_height_minusl[ i ]	ue(v)
}
loop_fdter_across_tiles_enabled_flag	u(l)
}

tile_un.it_size_idc spécifiés the size of a tile unit block in luma samples. The variables TileUnitSizeY, Pic WidthlnTileUnitsYand PicHeightlnTileUnitsY are derived as follows;

TileUnitSizeY = Max (CtbSizeY >> (tile_unit_size_idc), 8 ) (7-14)

PicWidthlnTileUnitsY = Ceil(pic_width_in_luma_samples + TileUnitSizeY) (7-14)

PicHeightlnTileUnitsY = Ceil(pic_height_in_luma_samples TileUnitSizeY) (7-14)

If tiles_enabledjlag is equal to 1, the variables PicWidthlnCtbsY, PicHeightlnCtbsY, PicSizelnCtbsY are modified as follows:

for(PicWidthInCtbsY = 0, i = 0; i <= num_tile_columns_minusl ; z’++ )

PicWidthlnCtbsY += Ceil(colWidth[ i] * TileUnitSizeY·^ CtbSizeY) (7-14) for(PicHeightInCtbsY = 0,j = 0;j <= num_tile_rows_minusl ; j++)

PicHeightlnCtbsY += Ceil(rowHeight[j] * TileUnitSizeYCtbSizeY) (7-14)

PicSizelnCtbsY = PicWidthlnCtbsY *PicHeightlnCtbsY (7-14) num^tilecolumnsminus 1 plus 1 spécifiés the number of tile columns partitioning the picture in units of tile unit blocks. num_tile_columns_minusl shall be in the range of 0 to PicWidthlnTileUnitsY- 1, inclusive. When not présent, the value of num_tile_columns_minus 1 is inferred to be equal to 0.

num_tile_rows_minusl plus 1 spécifiés the number of tile rows partitioning the picture in units of tile unit blocks. num tile rows minus 1 shall be in the range of 0 to PicHeightlnTileUnitsY- 1, inclusive. When not présent, the value of num_tile_rows_minus 1 is inferred to be equal to 0.

The variable NumTilesInPic is derived as follows:

NumTilesInPic - ( num_tile_columns minus 1 + 1 ) * ( num_tile_rows _minus 1 + 1)

The list colWidthf i ] for i ranging from 0 to num_tile_columns_minus 1, inclusive, specifying the width of the i-th tile column in units of tile unit blocks, is derived as follows:

if( uniform_spacing_flag ) for( i = 0; i <= num_tile_columns_minus 1 ; i++ ) posR — ((i + 1 ) PicWidthlnTileUnitsY) /(num_tile_columns minusl + 1 ) posL — (i · PicWidthlnTileUnitsY) / (num_tile_columns__mimisl + 1 ) colWidth[ i] = min(PicWidthInTileUnitsY-posL, posR -posL) else { colWidth[ num_tile_columns_minus 1 ] = PicWidthlnTileUnitsY (6-3 for( i = 0; i < num_tile_columns_minus 1 ; i++ ) { colWidth[ i ] = column_width_minusl [ i ] + 1 colWidth[num_tile_columns_minusl] -= colWidth[ i]

The list rowHeighfj] for j ranging from 0 to numjile_rows_minusl, inclusive, specifying the height of thej-th tile row in units of tile unit blocks, is derived as follows:

if( uniform_spacing_flag ) for( j = 0; j <= num_tile_rows_minus 1 ; j++ ) posB = ( (j + 1 ) * PicHeightlnTileUnitsY) / ( numjile_rows_minusl + 1 ) posT = (j * PicHeightlnTileUnitsY) / (num_tile_rows_minusl + 1 ) rowHeight [j] = min(PicHeightInTileUnitsY-posT, posB-posT) else { rowHeight[ num_tile_rows_minus 1 ] = PicHeightlnTileUnitsY (6-4) for( j = 0; j < num_tile_rows_minus 1 ; j++ ) { rowHeight[j ] = row_height_minusl [j ] + 1 rowHeight[ num_tile_rows_minusl ] -= rowHeight[j] } }

__

The list TileColX[ i ] for i ranging from 0 to num_tile_columns_minus 1 + 1, inclusive, specifying the X location of the top-left luma sample of the i-th tile column in units of luma samples, is derived as follows:

for ( TileColX[ 0 ] = 0, i = 0; i <= num_tile_columns_minus 1 ; i++ )

TileColX[ i + 1 ] = TileColX[ i] + colWidth[ i] * TileUnitSizeY

The list TileRowY[ j ] for j ranging from 0 to num_tile_rows_minus 1 + 1, inclusive, specifying the Y location of the top-left luma sample of the j-th tile row in units of luma samples, is derived as follows:

for ( TileRowY[ 0 ] — 0, j — 0; j <= num_tile_rows_minusl; j++ )

TileRowYjj + 1] = TileRowY[j] + rowHeightf j] * TileUnitSizeY

Segment groups, segments and units

Segment groups, segments, and units are now described. The term segment is used as a more general term than tiles, since the solutions in the current disclosure may be applied to different kinds of picture partitioning schemes and not only tile partitions known from HEVC and the VVC draft. In the current disclosure, a tile is one embodiment of a segment, but there may also be other embodiments of segments.

FIG. 3 shows a picture (10) of a video stream and an exemplary partitioning of the picture into units (8), segments (11) and segment groups (12). FIG. 3 (a) shows a picture (10) that consists of 64 units (8). FIG. 3 (b) shows the segment partition structure (13) of the same picture (10) consisting of 16 segments (11). The partition structure (13) is shown by dashed lines. Each segment (11) consists of a number of units. A segment can either consist of an integer number of complété units or a combination of complété and partial units. A number of segments form a segment group. FIG. 3 (c) shows the segment group partitioning of the same picture (10) which consists of 8 segment groups. The segment group may consist of segments in raster scan order. Altematively, the segment group may consist of any group of segments that together form a rectangle. Altematively, the segment group may consist of any subset of segments.

FIG. 4 shows a picture (10) where the dashed lines show a partition structure dividing the picture into four segments. FIG. 4 also shows three units (16, 17, 18). As shown in the figure, two units (16, 17) belong to one current segment (15) and one unit (18) belongs to a different, neighboring segment (14). The segments are independent with respect to other segments, which means that segment boundaries are handled similar to picture boundaries when decoding the units. This affects the dérivation process of éléments during decoding such as, for example, the dérivation of intra prédiction modes and the dérivation of quantization parameter values.

Intra modes are well known in the current art and are used and signaled for units that only use prédiction from previously decoded samples of the current picture for sample prédiction. It is common that the dérivation of the intra prédiction mode in a current unit (16) dépends on previously derived intra prédiction modes in other, neighboring units (17). With segments being independent, the dérivation of the intra prédiction mode in a current unit (16) may only dépend on previously derived intra prédiction modes in units (17) that belong to the current segment (15) and may not dépend on any intra prédiction mode in any unit (18) that belongs to a different segment (14).

This means that the partition structure in FIG. 4 makes the intra prédiction modes in units (18) in a different segment (14) unavailable for the dérivation of the intra prédiction mode for the units (16) in a current segment (15). Note that the mode in some units (18) in a different segment may well hâve been used for dérivation of an intra prédiction mode in a unit (16) in a current segment (15) if those units would hâve belonged to the same segment. Instead, the segment boundary may hâve the same effect on intra mode dérivation as a picture boundary for the units (16) in a current segment (15).

In the context of the current disclosure, a segment may be a tile or a slice and a segment group may be a tile group. In the current disclosure, the term “tile” and “segment” may be used interchangeably. In some embodiments, a unit may be équivalent to a CTU.

SUMMARY

According to the HEVC équations (A) and (B), the tile column widths (and row heights) are calculated by subtracting two ternis from each other in the form of ((i + 1) k ] |.i · k J where i is a non-negative integer and k is a rational number with numerator equal to PicWidthlnCtbsY and denominator equal to num_tile_columns_minus 1 +1. The output of such calculation when k is not an integer, may be equal to [ k ] or f k ] depending on the values of k and i. This inhérent feature causes variations as big as one CTU in tile column width and tile row height sizes. In the context of the current disclosure, such variations are referred to as the tile size ripple (See Table 2 below for some examples). The pattern for this ripple is not constant and dépends on the width of the picture in CTU and number of tile columns and rows which give the value of k, and the positioning of the tile on the tile grid determined by i. Some examples of the ripples in the tile column width using HEVC tile partitioning with uniform_spacing_flag equal to 1 are illustrated in Table 2. The same examples can be applied to tile row heights as well.

PicWidthlnCtbsY

num_tile_columns_minus 1

k

colWidth[ i ], i=0, 1, ... , num_tile_columns_minus 1

8	2	8/3	2, 3, 3 (smaller tile starts the grid) 2 3 3 H---1---1
10	3	10/4	2, 3, 2, 3 (mixed tile sizes) 2 3 2 3 H--H---1
100	30	100/31	3,3,3,3,4,3,3,3, 4,3,3,3,3,4, 3,3,3,4,3,3,3,3,4,3,3,3,4, 3, 3, 3, 4 (irregular mix of tile sizes)

Table 2

Table 2 shows tile column width calculated using HEVC tile partitioning with uniform_spacing_flag equal to 1 and given values for PicWidthlnCtbsY and num_tile_columns_minusl. Ripples in the values of colWidth[ i ] are visible.

This inconsistency in the final tile sizes is undesirable as due to a need to investigate the details of the input values and the code to predict the final tile size values. The ripple issue can happen in both horizontal and vertical directions. This makes it more diffîcult to détermine the correct horizontal and vertical sizes of a particular tile in the tile grid without examining the details.

Another problem is that in the current implémentation of HEVC for uniform spacing 10 of the files, if some rows or columns of files in the picture are removed, the tile boundaries inside the remaining part of the picture might move according to a new ripple pattern. This will require recalculating the tile size and addresses in the tile extraction process. An example illustrated in FIG. 5 as Table 500 shows how the tile column boundaries and so tile sizes might change in HEVC uniform tile spacing if some tiles are extracted from the original picture when the uniform_spacing_flag is equal to 1. The tile boundaries that change in case of removing some tile column(s) compared to the tile boundaries in the original picture are shown in bold Unes.

Table 500 in FIG. 5 illustrâtes tile boundaries using HEVC uniform tile spacing. Internai tile boundaries change between the original picture and after removing some tiles from the original picture. Parameters for the original picture are set as follows: uniform_spacing_flag = 1, PicWidthlnCtbsY = 10, num_tile_columns_minus 1 = 3, num tile rows minus 1 = 1.

JVET-L0359 proposes flexible tile splitting which allows for fïner tile unit size granularity by providing the possibility to use incomplète CTUs in the right and bottom edge of every tile (rather than only the right and bottom edge of the picture). FIG. 2 provides an example for a 2x2 tile segmentation using flexible tile splitting as in JVET-L0359 where the tile unit size is a quarter of the CTU size and uniform_spacing_flag is equal to 1.

As proposed in JVET-L0359, if uniform_spacing_flag is equal to 1, widths of the tile columns are determined using the following équation:

if( uniform_spacing_flag ) for( i = 0; i <= num_tile_columns_minus 1 ; i++) posR = ( ( i + 1 ) * PicWidthlnTileUnitsY ) / ( num_tile_columns_minusl + 1 ) posL — ( i * PicWidthlnTileUnitsY ) / ( num_tile_columns minus 1 + 1 ) colWidth[ i ] = min(PicWidthInTileUnitsY - posL, posR - posL) where:

PicWidthlnTileUnitsY = Ceil( pic_width_in_luma_samples - TileUnitSizeY )

A similar équation is used for determining the heights of the tile rows (rowHeightf i ])

The above implémentation shows that the ripple problem also exists for JVET-L0359 proposai. The introduced possibility for defining tile size with a granularity fmer than the CTU granularity introduces yet another artifact of inconsistent tile sizes as described here. Using the algorithm proposed in L0359, the tile partitioning does not stay consistent for some picture width and tile unit size values when the tile unit size changes e.g. into half or quarter. The reason is that the proposed équation for uniform tile splitting in L0359 allows for different tile unit sizes while it does not regularize the arrangement of the slightly larger or smaller tiles in the tile grid. Table 3 below shows some examples for the cases that the picture size is fixed, and the tile unit size is changed e.g. divided into half or quarter using the flexible tile splitting proposed in L0359. The final tile column widths flip as a resuit of the change in the tile unit size in a way that sometimes the larger tile width is on the left side and sometimes on the right side of the picture. This unpredictability is not desired.

Picture width (in luma samples)	Tile unit size	PicWidthlnTileUni tsY	numtile column s_minus 1		colWidthf i ], i=0, 1, ..., num_tilecolumns_ minusl (in tile unit size)	colWidthf i ], i=0, 1, ..., num_tile_columns_ minusl (in luma samples)
2160	32	Ceil(67.5) = 68	1	68/2	34, 34	1072, 1088 Smaller tile starts the grid
16	135	1	135/2	67,68	1088, 1072 Larger tile starts the grid
1080	16	Ceil(67.5) = 68	1	68/2	34, 34	544, 536 Larger tile starts the grid
8	135	1	135/2	67,68	536, 544 Smaller tile starts the grid
480	128	Ceil(3.75) = 4	1	4/2	2, 2	256, 224 Larger tile starts the grid
32	15	1	15/2	7, 8	224, 256 Smaller tile starts the grid

Table 3

Table 3 shows tile column width calculated using the flexible tile splitting as in L0359 when uniform_spacing_flag is set to 1.

We can conclude that a rule for organizing the inconsistency of the rounding effect on the tile sizes will make it easy to détermine the final tile sizes without the need for a detailed investigation of the code and input values. A systematic approach for regularizing the tile size ripples will also give consistent tile partitioning results for the original picture and a subset of the tiles from the original picture.

A separate problem is that the tiles resulting from uniform tile split can vary significantly in size. In Table 600 shown in FIG. 6, for example, the Tiles in the original picture for

HEVC uniform tile spacing hâve 4 different sizes with the smallest being 2x3 CTUs and the largest one being 3x4 CTUs.

A solution is proposed herein which regularizes the ripples on the size of the segments with a preferred order when the segment sizes cannot be exact according to the limited granulanty of the division. In the proposed solution, tiles with slightly smaller or larger sizes according to the rounding effect hâve a preferred arrangement. In one embodiment, the tile widths in a left to right scan direction, will only stay the same or decrease. The proposed solution disclosed herein may be applied to the tile column width and/or tile row height in a tile grid or to the width and height of individual tiles. In one embodiment, the tiles with slightly larger sizes (due to the given granularity and the rounding effect) locate in the top-left part of the picture and the tiles with slightly smaller sizes locate in the bottom-right part of the picture.

In alternative solutions, methods are proposed herein for uniform tiles in which the resulting tile sizes hâve equal sizes as far as it is possible.

Accordingly, in one aspect there is provided a method for decoding a picture. The method includes decoding information that the picture is partitioned into more than one segment based on one or more syntax éléments in a bitstream. The method also includes decoding information that the spatial segmentation is uniform based on the one or more syntax éléments in the bitstream. The method also includes determining a segment unit size based on the one or more syntax éléments or based on a predefïned segment unit size. The method also includes decoding a first value indicating a segment width from one or more code words in the bitstream. The method also includes decoding a second value indicating a segment height from the one or more code words in the bitstream. The method also includes deriving segment column widths based on a picture width in number of segment units and the first value. The method also includes deriving segment row heights based on a picture height in number of segment units and the second value. The method also includes deriving a spatial location for a current block based on the derived segment column widths and the derived segment row heights. The method also includes decoding the current block based on the derived spatial location.

The proposed solution keeps the width of the current tile independent of the previous tiles but only on the remaining number of units (in the column or row) that are going to be partitioned into the remaining number of tiles. As a resuit, the proposed solution for uniform spacing of tiles keeps the tile partitioning intact for the extracted and remaining tiles if tiles are extracted.

This will remove the need for recalculating the tile sizes in case of a picture split or tile extraction. In the current implémentation of HEVC for uniform spacing of the tiles, if some rows or columns of tiles in the picture are removed, the ripple pattern might change and the tile boundaries inside the remaining part of the picture might move according to the new ripple pattern.

Consistency is another advantage of the proposed solution. The proposed solution for uniform spacing of the tiles organizes the tile sizes (e.g. tile column width and the tile row height) and provides a rule for the final arrangement of tile sizes without any detailed investigation of the input parameters or the code. For instance, in one embodiment of the proposed solution when the picture width/height in tile unit is not divisible by the number of tile columns/rows, then ail the tiles rounded to larger sizes are found on the left/top part of the picture. The proposed solution also régulâtes ripples of the tile sizes in uniform tile spacing in case of changes to the tile unit size.

The proposed method also reduces complexity compared to HEVC and flexible tile split proposed in JVET-L0359. The proposed method has no multiplication and only 1 division per itération for determining the widths of the tile columns and the heights of the tile rows, while the HEVC method uses 2 multiplications and 2 divisions per itération.

In alternative solutions, the resulting tile sizes are uniform as far as it is possible.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated herein and form part of the spécification, illustrate various embodiments.

FIG. 1 shows an example of tile partitioning according to one embodiment.

FIG. 2A shows tile segmentation using HEVC tile partitioning-

FIG. 2B shows tile segmentation using flexible tile splitting.

FIG. 3 shows a picture of a video stream and exemplary partitioning.

FIG. 4 shows a picture according to some embodiments.

FIG. 5 shows a table according to some embodiments.

FIG. 6 shows a table according to some embodiments.

FIG. 7 is a flow chart illustrating a process according to an embodiment.

FIG. 8 is a flow chart illustrating a process according to an embodiment.

FIG. 9 is a diagram showing fùnctional units of a décoder according to one embodiment.

FIG. 10 is a diagram showing fùnctional units of an encoder according to one embodiment.

FIG. 11 is a block diagram of a node according to some embodiments.

FIG. 12 shows a picture according to one embodiment.

FIG. 13 shows a uniform tile structure according to one embodiment.

FIG. 14 shows a tile structure according to one embodiment.

FIG. 15 is a flow chart illustrating a process according to an embodiment.

FIG. 16 is a diagram showing fùnctional units of a décoder according to one embodiment.

DETAILED DESCRIPTION

The following terminology has been used to describe the embodiments:

Arithmetic operator is used for integer division with truncation of the resuit toward zéro. For example, 7 / 4 and -7 / -4 are truncated to 1 and -7 / 4 and 7 / -4 are truncated to -1.

Arithmetic operator is used for division in mathematical équations where no truncation or rounding is intended.

Ceil(x) gives the smallest integer greater than or equal to x.

Floor(x) gives the largest integer less than or equal to x.

The terms tile column width” and “tile width” are used interchangeably which means the solution can be applied when the tile column widths are being calculated in a tile grid or when the tile widths are being calculated individually (e.g. if there is no tile grid).

The terms “tile row height” and “tile height” are used interchangeably which means the solution can be applied when the tile row heights are being calculated in a tile grid or when the tile heights are being calculated individually (e.g. if there is no tile grid).

According to some embodiments, the proposed solution disclosed herein for defining the width (and equivalently the height) of the tiles for uniform_spacing_flag = 1 has the following éléments:

- in the loop for defming the width of each tile, the width for the tile is defined using the available remaining unit sizes which means the number of unit sizes in the row which are not yet allocated to a tile;

- the number of remaining unit sizes is then divided by the number of remaining tiles in the row;

- the obtained tile size is rounded towards the larger or smaller integer (Ceil() or FloorQ functions) according to the given rule for ordering the width of the tiles; and

- an optional element to recalculate the number of remaining unit sizes (e.g. CTUs) in every itération of the loop for defming the width of each tile.

The same éléments apply to defming the height of the tiles.

The proposed solution disclosed herein describes a décoder method for decoding a picture 10 from a bitstream, the method comprising deriving the sizes and/or locations for ail segments in the picture from the bitstream, wherein the picture 10 consists of a number of units 8 and a partition structure 13 partitions the picture into at least two segments 11 and the décoder détermines that the spatial segmentation is uniform by decoding one or more code words in the bitstieam, and the décoder détermines the number of spatial segments by decoding one or more code words in the bitstream, and the décoder détermines a tile unit size, and the partitioning of the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments, and the dérivation of the segment sizes is done in a loop over the number of segments, where inside the loop the number of remaining tile units to be segmented and the number of remaining segments are calculated.

In one example, the proposed solution replaces the following HEVC lines:

if( uniform_spacing_flag ) for( i = 0; i <= num_tile_columns_minus 1 ; i++ ) colWidth[ i ] = ( ( i + 1 ) * PicWidthlnCtbsY ) / ( num_tile_columns_ minus 1 + 1 ) _____________( i * PicWidthlnCtbsY ) / ( numtilecolumnsrninus 1 + 1 ) with the following lines:

if( uniform_spacing_flag ){

A = PicWidthlnCtbsY

B = num_tile_columns_minusl + 1 for( i = 0; i <= num_tile_columns_minusl ; i++ ){ colWidth[ i ] = Ceil( A - B)

A -= colWidth[ i ]

B -= 1 }

}

The proposée! method also reduces complexity compared to HEVC and flexible tile spht proposed in JVET-L0359. The proposed method has no multiplication and only 1 division per itération for determining the widths of the tile columns and the heights of the tile rows, while the HEVC method uses 2 multiplications and 2 divisions per itération.

Embodiment 1. Monotonie ripple

In an embodiment, the width of the segments in a row or the height of the segments in a column is never in ascending or never in descending order following a predefined scan direction. The segment may be a tile in a picture and so the tile sizes are monotonie (never ascending or never descending) in a scan direction. For example, for tile widths to be never ascending in the left to right scan direction means that the width of a tile is never larger than the width of another tile on the same row which is spatially located to the left of the first tile.

In the first embodiment, for a never ascending tile column width (left to right scan direction) and tile row height (top to bottom scan direction) on top of HEVC, the following HEVC functions:

if( uniform_spacing_flag ) for( i = 0; i <= num_tile_columns_minusl ; i++ ) colWidth[ i ] = ( ( i + 1 ) * PicWidthlnCtbsY ) / ( num_tile_columns_minusl + 1 ) ( i * PicWidthlnCtbsY ) / ( num_tile_columns_minus 1 + 1 ) and if( unifoim_spacing_flag ) for( j = 0; j <= num_tile_rows_minus 1 ; j++ ) rowHeight[ j ] = ( ( j + 1 ) * PicHeightlnCtbsY ) / ( num_tile_rows_minus 1 + 1 ) ( j * PicHeightlnCtbsY ) / ( num tile rows minus 1 + 1 ) are replaced with the following functions:

if( uniform_spacing_flag ) {

A = PicWidthlnCtbsY

B = num_tile_columns_minus 1 + 1 for( i = 0; i <= num_tile_columns_minus 1 ; i++ ) { colWidth[ i ] = Ceil( A B)

A -= co!Width[ i ]

B -= 1 and if( uniform_spacing_flag ) {

C = PicHeightlnCtbsY

D = num_tile_rows_minusl + 1 foi-( j = 0; j <= num_tile_rows_minusl ; j++ ) { rowHeight[ j ] = Ceil( C - D)

C -= rowHeight [ j ]

D -= 1

The resulting values in the colWidth and rowHeight lists are in units of luma coding tree block. If for instance the CTU size is equal to 128x128, the values are in units of 128 luma samples such that a value of 2 means 256 luma samples.

The colWidth and rowHeight lists are then used by the décoder to détermine the scan order of blocks in the picture. When block data is decoded, the spatial position of a block is based on the values in the colWidth and rowHeight lists. The décoder may construct conversion lists from tile scan addresses to raster scan addresses and the other way around using the values in colWidth and rowHeight. A décoder may then use the conversion lists during decoding to détermine the spatial positions of blocks. In HEVC, conversion lists are used and called CtbAddrRsToTs and CtbAddrTsToRs.

FIG. 6 shows table 600 which compares the tile size allocation for HEVC and the above exemplary implémentation of the first embodiment. As shown in table 600, in the proposed solution, the tile boundaries are kept the same as the original picture when tile columns are removed from the left or right or both sides of the picture. The rounding effect is govemed to put the slightly wider tiles on the left side of the picture in ail cases using the CeilQ function and recalculating the number of the remaining tile units in every itération of the loop over tiles to détermine tile column widths.

Table 600 shows how the internai tile boundaries change after removing some tile columns from the original picture using HEVC uniform tile spacing while the internai tile boundaries are kept intact in our proposed solution. The parameters for the original picture are set as follows: uniform_spacing_flag = 1, PicWidthlnCtbsY = 10, num_tile_columns_minusl = 3, num_tile_rows_minus 1 = 1.

Below is another example of the first embodiment, built on top of the équations proposed in JVET-L0359 which supports tile size granularities smaller than the CTU size. The following équation changes are proposed on top of JVET-L0359:

if( uniform_spacing_flag ) {

A - Pic WidthlnTileUnitsY ------B = num_tile_columns_minusl + 1 for( i = 0; i <= num_tile_columns_minus 1 ; i++ ) {

P^OSR ~ ¹ + 1 ) * PicWidthlnTileUnitsY ) / ( num_tilc_columnû_minus 1 + 1 )

P^OSL “ ( i * PicWidthlnTileUnitsY ) / ( num_tilc_columns_minua 1 + I ) eolWidthf i ] - min(Pic WidthlnTileUnits Y—posL, posR—pesL) colWidthf i ] = Ceil( A B)

A -= colWidth[ i ]

B -= 1 } } where:

PicWidthlnTileUnitsY = Ceil( pic_width_in_luma_samples - TileUnitSizeY ) and equivalently for the tile row heights the following changes are proposed:

if( uniform_spacing_flag ) {

C = PicHeightlnTileUnitsY

D = num_tile_rows_minus 1 + 1 for(j = 0;j <= num_tile_rows_minus 1 ;j++ ) {

-----------Ρθ8Β ^ ( ( i + 1 ) * PicHeightlnTileUnitsY ) / ( num_tile_rows_minusl + 1 ) ----------P^osT~-H--* PicHeightlnTileUnitsY ) / ( numjile_rowû_minuûl + 1 ) ----------fowHeight[ i ] - min(PicHeightInTileUnitsY posT, posB posT) rowHeight[ j ] = Ceil( C - D)

C -= rowHeight[ j ]

D -= 1 where:

PicHeightlnTileUnitsY = Ceil( pic_height_in_luma_samples - TileUnitSizeY )

The resulting values in the colWidth and rowHeight lists are in units of luma tile units. If for instance the tile unit size is equal to 32x32, the values are in units of 32 luma samples such that a value of 2 means 64 luma samples.

Table 4 compares the results for the width of the tiles between JVET-L0359 and the proposed solution in Embodiment 1 for different picture widths values. The results for JVET-L0359 show inconsistency in the width of the tile columns (colWidth[i]) when the tile unit size changes while the proposée! solution in Embodiment 1 provides consistent width of the tile columns (colWidth[i]) when the tile unit size changes as it consistently prioritizes the slightly larger tiles to be put on the left side of the picture.

Picture width (in luma samples )	Tile unit size	PicWidthln TileUnitsY	JVET-L0359	First Embodiment
colWidthf i ], i=0, 1 (in tile unit size)	colWidth[ i ], i=0, 1 (in luma samples)	colWidth[ i ], i=0, 1 (in tile unit size)	colWidthf i ], i=0, 1 (in luma samples)
2160	32	Ceil(67.5) = 68	34, 34	1072, 1088 Smaller tile starts the grid	34, 34	1088, 1072 Larger tile starts the grid
16	135	67,68	1088, 1072 Larger tile starts the grid	68,67	1088, 1072 Larger tile starts the grid
1080	16	Ceil(67.5) = 68	34, 34	544, 536 Larger tile starts the grid	34, 34	544, 536 Larger tile starts the grid
8	135	67,68	536, 544 Smaller tile starts the grid	68,67	544, 536 Larger tile starts the grid
480	128	Ceil(3.75) = 4	2, 2	256, 224 Larger tile starts the grid	2, 2	256, 224 Larger tile starts the grid
32	15	7, 8	224,256 Smaller tile starts the grid	8, 7	256, 224 Larger tile starts the grid

Table 4

Table 4 shows tile column width calculated when uniform_spacing_flag = 1, num_tile_columns_minus 1 = 1, using the flexible tile splitting as in JVET-L0359 compared with the proposed solution in the first embodiment.

In the first embodiment, a décoder may perform ail or a subset of the following steps:

1. Décodé information that one or more pictures are partitioned into more than one segment from one or more syntax éléments in the bitstream. The syntax is preferably located in a picture parameter set. The syntax may specify a number R indicating the number of segment rows and a number C indicating the number of segment columns.

2. Décodé information that the spatial segmentation is uniform from one or more syntax éléments in the bitstream. The syntax is preferably located in a picture parameter set. The syntax may consist of a one-bit flag specifying whether the spatial segmentation is uniform or not.

3. Détermine a segment unit size S either from one or more syntax éléments or by using a predefïned segment unit size. If a predefined unit size is used, it may be equal to the size of a CTU or the size of a CTU in one dimension. For instance, if the CTU size is equal to 128x128, the segment unit size S may be equal to 128 (or 128x128).

4. Calculate the size of the picture in number of segment units. The calculation may be done separate for the height and width of the picture such that the horizontal size (HS) is set equal to the picture width in luma samples divided by the segment unit size S. The vertical size (VS) may be set equal to the picture height in luma samples divided by the segment unit size.

5. Dérivé the width and heights of ail segments from the number of segments in the picture and the segment unit size S. The dérivation is done in a loop over the number of segments where the number of segments yet to be segmented and the size ofthe picture yet to be segmented in number of segment units is updated in each itération ofthe loop.

The dérivation may be done in two separate loops:

a. Dérivé the segment column widths from the picture width in number of tile units and the number of segment columns C by the following substeps:

i. Set the picture width yet to be segmented (A) equal to the value HS ii. Set the number of segment columns yet to be segmented (B) equal to the value C iii. Deiive the column widths in a loop where one width value is derived per itération and where the number of segment columns yet to be segmented (B) and the picture width yet to be segmented (A) are both updated in each itération. The itération may be executed C times.

1. The derived column width W may be set equal to Ceil( A - B)

2. The variable A may then be updated to A-W and the variable B may be updated to B-1

b. Dérivé the segment row heights from the picture height in number of tile units and the number of segment rows R by the following substeps:

i. Set the picture height yet to be segmented (A) equal to the value VS ii. Set the number of segment rows yet to be segmented (B) equal to the value R iii. Dérivé the row heights in a loop where one height value is derived per itération and where the number of segment rows yet to be segmented (B) and the picture height yet to be segmented (A) are both updated in each itération. The itération may be executed R times.

1. The derived row height H may be set equal to Ceil( A - B)

2. The variable A may then be updated to A-H and the variable B may be updated to B-l

6. Dérivé the spatial location for a current block using derived segment widths and derived segment heights.

7. Décodé the current block using the derived spatial location. Store the decoded sample values for the current block in memory at memory positions corresponding to the derived spatial location.

In a variant of this embodiment, the function Ceil() can be replaced by function Floor(), in only horizontal, or only vertical or both directions.

In a variant of this embodiment, a flag may choose between the two functions Ceil() and Floor(). In some embodiments, there may be two independent flags for the horizontal and vertical directions.

Embodiment 2. Specified order

In the second embodiment, the width of the segments in a row or the height of the segments in a column follows a specified order. This specified order may be signaled in the bitstieam using a template pattern in the form of a sequence of bits. Segments may be tiles in a picture and so in this embodiment, the shape of the preferred ripple on the tile sizes is specified. For example, ail slightly wider tiles are in the left side of the picture. This may be done by a template pattern expiessed in the form of a sequence of bits that spécifiés Ceil() or FloorQ function in every itération of the loop over tiles to specify the tile width (or height). Function Ceil() may be represented by 1 and function Floor() may be represented by 0 in the template bit sequence. As an example, template 110 would specify Ceil() function in the first two tiles and function Floor() in the third itération of the loop for specifying the tile size. The pattern may be periodically repeated if the number of tiles is larger than the length of the template bit sequence.

Embodiment 3. Binary tile splits

In the third embodiment, the binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture. Segments may be tiles in a picture and so the binary partitioning is used for partitioning the picture into 2ⁿ tiles with uniform tile sizes. A predefined ripple pattern (as in the second embodiment) may be used in combination with this embodiment. The binary partitioning may carry on hierarchically until the algorithm reaches the specified number of segments or only up to a defined number of steps and the rest of the segment divisions being carried out by other methods. As an example, the total size is divided by 2 in a first step where it is specified to assign the smaller or larger segment to the left or right. In each of the subséquent steps, each of the left and right segments are divided into two parts using the next binary partitioning level and the specified rule for the position of possibly smaller or larger segment.

Embodiment 4. Default ordering of the ripple

In the fourth embodiment, the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments. Segments may be tiles in a picture and so a default preferred ordering is defined for managing the ripples in the segment sizes. The default ripple pattern may be signaled in the bitstream. In a variant of this embodiment the default pattern may be overwritten. In another variant of this embodiment a flag can specify if the default ordering or another specified ordering is being used.

Embodiment 5.

In the fîfth embodiment, the aim is to achieve as many large equally sized tiles by using a uniform spacing method.

This may be achieved by decoding a TileWidth value from one or more code words in the bitstream. Then the width values of ail tile columns in the picture except one is set equal to the decoded TileWidth value. The width value of the one remaining tile column is set equal to the picture width value minus the sum of the width values of ail tile columns except the one remaining tile column. The width value of the one remaining column may also be equal to TileWidth value.

Altematively, or additionally, a TileHeight value is decoded from one or more code words in the bitstream. Then the height values of ail tile rows in the picture except one is set equal to the derived TileHeight value. The height value of the one remaining tile row is set equal to the picture height value minus the sum of the height values of ail tile rows except the one remaining tile 5 row. The height value of the one remaining row may also be equal to the TileHeight value.

The method in this embodiment results in most tiles being of equal size, for example, as illustrated in picture 1200 shown in FIG. 12 where most tiles are of size 4x4 CTUs or tile units.

The embodiment can be implemented in HEVC v5 or the current VVC draft by remove the following text from the HEVC v5 or the draft VVC spécification.

if( uniform_tile_spacing_flag ) for( i = 0; i <= num_tile_columns_minus 1 ; i++ )

ColWidth[ i ] = ( ( i + 1 ) * PicWidthlnCtbsY ) / ( num_tile_columns_minus 1 + 1 ) ( i * PicWidthlnCtbsY ) / ( num_tile_columns_minus 1 + 1 ) if( uniform_tile_spacing_flag ) for( j = 0; j <= num_tile_rows_minus 1 ; j++ )

RowHeight[ j ] = ( (j + 1 ) * PicHeightlnCtbsY ) / ( num_tile_iO^ws_^minus 1 + 1 ) (j * PicHeightlnCtbsY ) / ( num_tile_rows_minusl + 1 )

The removed text above is replaced by the following text in the HEVC v5 or VVC draft spécification respectively.

if( uniform_tile_spacing_flag ) {

RemainingWidthlnCtbsY = PicWidthlnCtbsY i=0 while( RemainingWidthlnCtbsY > tile_width ) {

ColWidth[i++] = tile_width

RemainingWidthlnCtbsY -= tile_width }

ColWidthfi] = RemainingWidthlnCtbsY num_tile_col umnsminus 1 = i }

if( uniform_tile_spacing_flag ) {

RemainingHeightlnCtbsY = PicHeightlnCtbsY i=0 while( RemainingHeightlnCtbsY > tile_height ) { RowHeight[i++] = tile_height RemainingHeightlnCtbsY -= tile_height }

RowHeight[i] = RemainingHeightlnCtbsY num_tile_rows_minus 1 = i

The syntax and semantics for tile_width and tile_height may look as follows:

pic_parameter_set_rbsp( ) {	Descriptor
...
tilesenabledflag	u(l)
...
if( tiles_enabled_flag ) {
uniformspacingflag	u(l)
if( uniform_spacing_flag ) {
tilewidth	ue(v)
tileheight	ue(v)
} else {
numtilecolumnsminusl	ue(v)
n u mtiler o wsmin u s 1	ue(v)
for( i = 0; i < num_tile_columns_minusl; i++ )
column_width_minusl[ i ]	ue(v)
for( i = 0; i < num tile rows minus 1; i++ )
row_height_minusl[ i ]	ue(v)
}
loopfïlteracrosstilesenabledflag	u(l)
}
...

Table 5. Tile syntax for the seventh embodiment

The syntax and semantics are explained in further detail below:

num tile columns minusl plus 1 spécifiés the number of tile columns partitioning the picture. num_tile_columns_minus 1 shall be in the range of 0 to PicWidthlnCtbsY - 1, inclusive. When tiles enabled flag is equal to 0, the value of num_tile_columns_minus 1 is inferred to be equal to 0. Otherwise, if uniform_spacing_flag is equal to 1, the value of num_tile_columns minus 1 is derived as shown above.

num tile rows minusl plus 1 spécifiés the number of tile rows partitioning the picture. num_tile_rows_minus 1 shall be in the range of 0 to PicHeightlnCtbsY - 1, inclusive. When tiles_enabled_flag is equal to 0, the value of num_tile_rows_minus 1 is inferred to be equal to 0. Otherwise, if uniform_spacing_flag is equal to 1, the value of num_tile_rows_minus 1 is derived as shown above.

When tiles_enabled_flag is equal to 1, num_tile_columns_minusl and num_tile_iOws_minus 1 shall not be both equal to 0.

tile width spécifiés the width of ail tiles not belonging to the last tile column. tile_width shall be in the range of 1 to PicWidthlnCtbsY - 1, inclusive.

tileheight spécifiés the height of ail tiles not belonging to the last tile row. tile height shall be in the range of 1 to PicHeightlnCtbsY - 1, inclusive.

A décoder may perform ail or a subset of the following steps for this embodiment:

1. Décodé information that one or more pictures are partitioned into more than one segment from one or more syntax éléments in the bitstream. The syntax is preferably located in a picture parameter set.

3. Détermine a segment unit size S either from one or more syntax éléments or by using a predefined segment unit size. If a predefined unit size is used, it may be equal to the coding tree unit. For instance, if the CTU size is equal to 128x128, the segment unit size S may be equal to 128 (or 128x128).

4. Calculate the size of the picture in number of segment units. The calculation may be done separate for the height and width such that the horizontal size HS is set equal to the picture width in luma samples divided by the segment unit size. The vertical size VS may be set equal to the picture height in luma samples divided by the segment unit size.

5. Décodé a value TileWidth représentative of a tile width in S units from a code word in the bitstream. The code word may be a UVLC code word. The code word may be decoded as the tile width minus one and the value TileWidth may therefore be set equal to the decoded value plus 1.

6. Décodé a value TileHeight représentative of a tile height in S units from a code word in the bitstream. The code word may be a UVLC code word. The code word may be decoded as the tile height minus one and the value TileWidth may therefore be set equal to the decoded value plus 1.

7. Dérivé the segment column widths from the picture width in number of tile units and the TileWidth variable by the following substeps:

a. Set the picture width yet to be segmented (A) equal to the value HS

b. Set a variable i equal to the value 0

c. Repeatedly execute the following substeps as long as the picture width yet to be segmented (A) is larger than the value TileWidth:

i. Set the column width of the i-th segment column to TileWidth ii. Subtract the value TileWidth from the value A iii. Increase the value of the variable i by 1

d. Set the column width of the i-th segment column to the value A

e. Set a variable num_tile_columns_minus 1 equal to the value of variable i, or altematively, set a variable representing the number of tile columns in the picture equal to the value of the variable i plus 1

8. Dérivé the segment row heights from the picture height in number of tile units and the TileHeight variable by the following substeps:

a. Set the picture height yet to be segmented (A) equal to the value VS

b. Set a variable i equal to the value 0

c. Repeatedly execute the following substeps as long as the picture height yet to be segmented (A) is larger than the value TileHeight:

i. Set the row height of the i-th segment row to TileHeight ii. Subtract the value TileHeight from the value A iii. Increase the value of the variable i by 1

d. Set the row height of the i-th segment row to the value A

e. Set a variable num_tile_rows_minusl equal to the value of variable i, or altematively, set a variable representing the number of tile rows in the picture equal to the value of the variable i plus 1

9. Dérivé the spatial location for a current block using derived segment widths and derived segment heights.

10. Décodé the current block using the derived spatial location. Store the decoded sample values for the current block in memory at memory positions corresponding to the derived spatial location.

Embodiment 6.

In the sixth embodiment, one of multiple methods for uniform tile partitioning may be used. In one embodiment, there are one or more syntax éléments indicating which one ofthe multiple methods to use. The one or more syntax éléments may be a flag specifying which of two methods that is used. The one or more syntax éléments may be présent in a parameter set such as a picture parameter set but this embodiment is not constrained to only that location. The set of multiple methods may include any method disclosed herein as well as methods known in the art such as the methods described in the HEVC v5 spécification and the draft VVC spécification.

Embodiment 7. Small ones to the left or top

In embodiments 5-6 described above in the current disclosure, the tiles hâve been ordered such that the full-size tiles are located to the left and top in the tile structure ofthe picture.

In the seventh embodiment, the tiles are ordered in the opposite way as in embodiments 5-6, i.e. the tile width remainder is the width of the leftmost tile(s) in the uniform tile structure and/or the tile height remainder is the height of the topmost tile(s) in the uniform tile structure. With other words the full-size tiles are located to the right and/or the bottom and the smaller sized tiles with the width equal to the tile width remainder and/or with the height equal to the tile height are located to the left and/or to the top in the tile structure. This is exemplified in FIG.

with a picture 1300 that is 896x640 pixels. Solid lines represent tile borders and dashed lines represent CTU borders. Each CTU is 64x64 pixels. FIG. 13 shows an example of uniform tile structure with full size tiles to the bottom and right and the smaller tiles located to the left and to the top.

Embodiment 8. Alignment with the tile group boundaries

In the eighth embodiment, the sizes of the tiles are ordered according to any of the previous embodiments with the addition that the tiles are grouped in tile groups where each tile group may contain a row/column of tiles with the tile width/height equal to a tile height/with remainder.

This is illustrated in FIG. 14 where a tile group is represented with large dotted lines, tiles are lepresented with solid lines and CTUs are represented with dashed lines. Note that not ail tile groups may hâve tiles with equal tile width remainder depending on if the total remainder is equally divisible by the number of CTUs. FIG. 14 shows an example of tile structure with tile groups where each tile group may contain a tile with width and/or height equal to the a tile width/height remainder value.

In the example shown in FIG. 14, the tile group width is 5 CTUs and the tile width is 2 CTUs. Since the width of the picture is 14 CTUs the picture is divided into 3 tile groups in horizontal direction, with 5, 5, and 4 tiles respectively. The two first tile groups are divided horizontally into two full size tiles of 2 CTUs and one tile with the remainder tile width of 1 CTU. The leftmost tile group is equally divisible by 2 CTUs so no tile with remainder tile width is needed. There may also be a scénario with larger tiles containing more CTUs (e.g. 4 tiles horizontally) where the remainders would be 3, 3, 2, i.e. ail tile groups hâve tiles with tile width remainder, but the tile width remainder is not the same for ail tile groups.

FIG. 15 is flow chart illustrating a process 1500 according to an embodiment. Process 1500 is a method for decoding a picture. The 1500 method includes decoding information that the picture is partitioned into more than one segment based on one or more syntax éléments in a bitstream (step 1502); decoding information that the spatial segmentation is uniform based on the one or more syntax éléments in the bitstream (step 1504); determining a segment unit size based on the one or more syntax éléments or based on a predefmed segment unit size (step 1506); decoding a first value indicating a segment width from one or more code words in the bitstream (step 1508); decoding a second value indicating a segment height from the one or more code words in the bitstream (step 1510); deriving segment column widths based on a picture width in number of segment units and the first value (step 1512); deriving segment row heights based on a picture height in number of segment units and the second value (step 1514); deriving a spatial location for a current block based on the derived segment column widths and the derived segment heights (step 1516); and decoding the current block based on the derived spatial location (step 1518).

In some embodiments, deriving segment column widths comprises setting column width values of ail segment columns in the picture except one column equal to the first value, and setting the column width value of the one remaining segment column equal to a picture width minus the sum of the width values of ail segment columns except the one segment column.

In some embodiments, deriving segment row heights comprises setting row height values of ail segment rows in the picture except one row equal to the second value, and setting the row height value of the one remaining segment row equal to a picture height minus the sum of the height values of ail segment rows except the one segment row.

In some embodiments, the one or more syntax éléments is located in a picture parameter set.

In some embodiments, the one or more syntax element comprises a one-bit flag specifying whether the spatial segmentation is uniform.

In some embodiments, the predetermined segment unit size is equal to a coding tree unit

In some embodiments, calculating the size of the picture in segment comprises: calculating the size of the picture segment for the height and calculating the size of the picture segment for the width.

In some embodiments, the first value is a TileWidth value représentative of a tile width in segment units, and the second value is a TileHeight représentative of a tile height in segment units.

FIG. 16 is a diagram showing functional units of a décoder 1602 according to some embodiments. As shown in FIG. 16, décoder 1602 includes a first decoding unit 1604 for decoding information that the picture is partitioned into more than one segment based on one or more syntax éléments in a bitstream; a second decoding unit 1606 for decoding information that the spatial segmentation is uniform based on the one or more syntax éléments in the bitstream; a determining unit 1608 for determining a segment unit size based on the one or more syntax éléments or based on a predefined segment unit size; a third decoding unit 1610 for decoding a first value indicating a segment width from one or more code words in the bitstream; a fourth decoding unit 1612 for decoding a second value indicating a segment height from the one or more code words in the bitstream; a first denving unit 1614 for deriving segment column widths based on a picture width in number of segment units and the first value; a second deriving unit 1616 for deriving segment row heights based on a picture height in number of segment units and the second value; a third deriving unit 1618 for deriving a spatial location for a current block based on the derived segment column widths and the derived segment heights; and a fifth decoding unit 1620 for decoding the current block based on the derived spatial location.

FIG. 7 is a flow chart illustrating a process 700 according to an embodiment. Process 700 is a method for decoding a picture (10) comprising a number of units (8) from a bitstream, the picture being partitioned into at least two spatial segments (11) by a partition structure (13). The method includes decoding one or more code words in the bitstream (step 710); determining that the partition structure is uniform based on the one or more code words (step 720); determining the numbei of spatial segments based on the one or more code words (step 730); determining a segment unit size (step 740); and deriving the sizes and/or locations for ail spatial segments in the picture from the one or more code words (step 750), wherein the dérivation of the segment sizes and/or location comprises a first loop over the number of spatial segments in a first dimension or direction, and the number of remaining segment units in the first dimension or direction to be segmented and the number of remaining segments in the first dimension are calculated inside the first loop.

In some embodiments, the dérivation of the segment sizes and/or location comprises a second loop over the number of spatial segments in a second dimension or direction other than the fil st dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented and the number of remaining segments in the second dimension or direction are calculated inside the second loop.

In some embodiments, the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction.

In some embodiments, the width of the segments in a row or the height of the segments in a column follows a specified order.

In some embodiments, the width of the segments in a row or the height of the segments in a column are in a never ascending or a never descending order.

In some embodiments, a binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture.

In some embodiments, the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments.

In some embodiments, the segment unit size is equal to the size of the coding tree unit (CTU).

In some embodiments, the segment unit size is smaller than the size of the coding tree unit (CTU). In some embodiments, the segment unit size is larger than the size of the CTU. In some embodiments, any segment is a tile.

In some embodiments, deriving the sizes comprises:

deriving a list Sizes[] as:

A = PicWidthlnTileUnits

B = NumberOISegmentColumns for( i = 0; i < NumberOfSegmentColumns; i++ ) {

Sizes[ i ] = Round( A B)

A = A - Sizes[ i ]

B = B- 1 }

where NumberOfSegmentColumns is the number of segment columns, PicWidthlnTileUnits is the width of the picture in tile units, Round() is either the Floor() function or the Ceil() function, and is division without truncation or rounding.

In some embodiments, deriving the sizes comprises:

deriving a list Sizes[] as:

A = PicHeightlnTileUnits

B = NumberOfSegmentRows for( i = 0; i < NumberOfSegmentRows; i++ ) {

Sizes[ i ] = Round( A B)

A = A - Sizes[ i ]

B = B- 1 }

where NumberOfSegmentRows is the number of segment rows, PicHeightlnTileUnits is the height of the picture in tile units, Round() is either the Floor() function or the Ceil() function, and is division without truncation or rounding.

In some embodiments, the segments (11) are independent with respect to other segments (11) such that the dérivation of any intra prédiction mode for any unit (16) in a current segment (15) dépends only on previously derived intra prédiction modes in units (17) that belong to the current segment (15) and does not dépend on any intra prédiction mode in any unit (18) that belongs to a different segment (14).

In some embodiments, the method includes a further step of partitioning the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments.

FIG. 8 is a flow chart illustrating a process 800 according to an embodiment. Process 800 is a method for encoding a picture (10) comprising a number of units (8) into a bitstream, the picture being partitioned into at least two spatial segments (11) by a uniform partition structure (13). The method includes encoding the information that the partition structure (13) is uniform by encoding one or more code words into the bitstream (step 810); encoding the number of spatial segments by encoding one or more code words into the bitstream (step 820); determining a segment unit size (step 830); and deriving and encoding the sizes and/or locations for ail spatial segments in the picture into the bitstream (step 840), wherein the dérivation of the segment sizes comprises a first loop over the number of spatial segments in a first dimension or direction, and the number of remaining segment units in the first dimension or direction to be segmented and the number of remaining segments in the first dimension or direction are calculated inside the first loop.

In some embodiments, the dérivation of the segment sizes and/or location comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented and the number of remaining segments in the second dimension or direction are calculated inside the second loop.

FIG. 9 is a diagram showing fimctional units of a décoder 902 according to some embodiments. As shown in FIG. 9, décoder 902 includes a decoding unit 904 for decoding one or more code words in the bitstream; a first determining unit 906 for determining that the partition structure is uniform based on the one or more code words; a second determining unit 908 for determining the number of spatial segments based on the one or more code words; a third determining unit 910 for determining a segment unit size; and a deriving unit 912 for deriving the sizes and/or locations for ail spatial segments in the picture from the one or more code words, wherein the dérivation of the segment sizes and/or location comprises a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, the number of remaining segment units in the first dimension to be segmented and the number of remaining segments in the first dimension are calculated inside the first loop, and the number of remaining segment units in the second dimension to be segmented and the number of remaining segments in the second dimension are calculated inside the second loop.

FIG. 10 is a diagram showing functional units of an encoder 1002 according to some embodiments. As shown in FIG. 10, encoder 1002 includes a first encoding unit 1004 for encoding the information that the partition structure (13) is uniform by encoding one or more code words into the bitstream; a second encoding unit 1006 for encoding the number of spatial segments by encoding one or more code words into the bitstream; a determining unit 1008 for determining a segment unit size; and a deriving unit 1010 for deriving and encoding the sizes and/or locations for ail spatial segments in the picture into the bitstream, wherein the dérivation of the segment sizes comprises a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, the number of remaining segment units in the first dimension to be segmented and the number of remaining segments in the first dimension are calculated inside the first loop, and the number of remaining segment units in the second dimension to be segmented and the number of remaining segments in the second dimension are calculated inside the second loop.

In some embodiments, the encoder is configured to define a partition structure that divides a picture into a number of uniform spatial segments, wherein each spatial segment comprises at least one unit, and wherein dérivation of the segment sizes is performed in a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, wherein the number of remaining segment units in the first dimension to be segmented and the number of remaining segments in the first dimension are calculated inside the first loop, and wherein the number of remaining segment units in the second dimension to be segmented and the number of remaining segments in the second dimension are calculated inside the second loop; encode the plurality of spatial segments in accordance with the partition structure to generate a plurality of coded spatial segments, wherein each coded spatial segment corresponds to one of the spatial segments of the partition structure, and each coded spatial segment is independent such that dérivation of any intra prédiction mode for a first unit of the first spatial segment dépends on a derived intra prédiction mode for a second unit of the first spatial segment and is independent of any intra prédiction mode for units of other spatial segments of the partition structure; and generate a bit stream comprising the plurality of coded spatial segments and information indicating the uniform partition structure used to divide the picture into the plurality of spatial segments.

FIG. 11 is a block diagram of an apparatus 1100 for implementing décoder 902, 1602 and/or encoder 1002, according to some embodiments. When apparatus 1100 implements a décoder, apparatus 1100 may be referred to as a “decoding apparatus 1100,” and when apparatus 1100 implements an encoder, apparatus 1100 may be referred to as an “encoding apparatus 1100.” As shown in FIG. 11, apparatus 1100 (a.k.a., “node”) may comprise: processing circuitry (PC) 1102, which may include one or more processors (P) 1155 (e.g., a general purpose microprocessor and/or one or more other processors, such as an application spécifie integrated circuit (ASIC), fieldprogrammable gâte arrays (FPGAs), and the like); a network interface 1148 comprising a transmitter (Tx) 1145 and a receiver (Rx) 1147 for enabling the apparatus 1100 to transmit data to and receive data from other nodes connected to a network 1110 (e.g., an Internet Protocol (IP) network) to which network interface 1148 is connected; and a local storage unit (a.k.a., “data storage System”) 1108, which may include one or more non-volatile storage devices and/or one or more volatile storage devices. In embodiments where PC 1102 includes a programmable processor, a computer program product (CPP) 1141 may be provided. CPP 1141 includes a computer readable medium (CRM) 1142 storing a computer program (CP) 1143 comprising computer readable instructions (CRI) 1144. CRM 1142 may be a non-transitory computer readable medium, such as, magnetic media (e.g., a hard disk), optical media, memory devices (e.g., random access memory, flash memory), and the like. In some embodiments, the CRI 1144 of computer program 1143 is configured such that when executed by PC 1102, the CRI causes the apparatus 1100 to perform steps described herein (e.g., steps described herein with reference to the flow charts). In other embodiments, the apparatus 1100 may be configured to perform steps described herein without the need for code. That is, for example, PC 1102 may consist merely of one or more ASICs. Hence, the features of the embodiments described herein may be implemented in hardware and/or software.

Summary ofVarious embodiments

Al. A method for decoding a picture, the method comprising: decoding information that the picture is partitioned into more than one segment based on one or more syntax éléments in a bitstream; decoding information that the spatial segmentation is uniform based on the one or more syntax éléments in the bitstream; determining a segment unit size based on the one or more syntax éléments or based on a predefined segment unit size; decoding a first value indicating a segment width from one or more code words in the bitstream; decoding a second value indicating a segment height from the one or more code words in the bitstream; deriving segment column widths based on a picture width in number of segment units and the first value; deriving segment row heights based on a picture height in number of segment units and the second value; deriving a spatial location for a current block based on the derived segment column widths and the derived segment row heights; and decoding the cument block based on the derived spatial location.

A2. The method of embodiment Al, wherein deriving segment column widths comprises: setting column width values of ail segment columns in the picture except one column equal to the first value, and setting the column width value of the one remaining segment column equal to a picture width minus the sum of the width values of ail segment columns except the one segment column.

A3. The method of embodiment Al or A2, wherein deriving segment row heights comprises: setting row height values of ail segment rows in the picture except one row equal to the second value, and setting the row height value of the one remaining segment row equal to a picture height minus the sum of the height values of ail segment rows except the one segment row.

A4. The method of any one of embodiments Al-A3, wherein the one or more syntax éléments is located in a picture parameter set.

A5. The method of any one of embodiments Al-A4, wherein the one or more syntax éléments comprises a one-bit flag specifying whether the spatial segmentation is uniform.

A6. The method of any one of embodiments A1-A5, wherein a segment unit is a coding tree unit or a coding tree block.

A7. The method of any one of claims A1-A6, further comprising calculating the size of the picture in number of segment units.

A8. The method claim A7, wherein calculating the size of the picture in number of segment units comprises: calculating the size of the picture segment for the height and calculating the size of the picture segment for the width.

A9. The method of any one of claims A1-A8, wherein the first value represents a tile width in segment units, and the second value represents a tile height in segment units.

A10. The method of any one of claims A1-A9, wherein decoding the first value from one or more code words in the bitstream consists of decoding a value of a particular code word in the bitstream and adding 1 to the decoded value.

Al 1. The method of any one of claims A1-A10, wherein deriving segment column widths comprises:

setting a variable, A, to a remaining width value; and determining whether a value equal to (A - TileWidth) is less than TileWidth, wherein TileWidth is equal to the first value.

Al 2. The method of claim Ail, wherein if it is determined that the value of (A TileWidth) is not less than the first value, then performing the steps of:

setting a first column width variable equal to TileWidth; and determining whether a value equal to (A - (2 x TileWidth)) is less than TileWidth.

Al3. The method of claim Al 1 or A12, wherein determining whether the value (A TileWidth) is less than TileWidth comprises:

setting A equal to (A - TileWidth); and comparing A with TileWidth.

A14. The method of claim A12 or A13, wherein if it is determined that A - TileWidth is less than TileWidth, then setting a second column width variable equal to A - TileWidth.

Al5. The method of claim Al5, wherein setting the second column width variable equal to A - TileWidth is only performed if A - TileWidth is greater than 0.

A16. The method of claim A14 or A15, further comprising setting a variable representing a number of tile columns in the picture equal to the value of a variable i or equal to the value of the variable i plus 1, wherein i is an integer such that the value (A - ((i-1) x TileWidth)) is not less than TileWidth but the value (A - (i x TileWidth)) is less than TileWidth.

Al 7. The method of any one of claims Al-A 10, wherein deriving segment column widths comprises:

1) setting a variable, A, to a remaining width value; and

2) setting a variable, i, to an initial value;

3) determining whether a value equal to (A - (i x TileWidth)) is less than TileWidth, wherein TileWidth is equal to the first value; and

4) if it is determined that the value equal to (A - (i x TileWidth)) is not less than TileWidth, then performing the steps of: setting a variable col_width[i] equal to TileWidth, incrementing i, and repeating steps 3) and 4).

Al 8. The method of claim A17, wherein after it is determined that the value equal to (A - (i x TileWidth)) is less than TileWidth, then performing setting col_width[i] equal to A and incrementing i.

While various embodiments are described herein (including the Appendix, if any), it should be understood that they hâve been presented by way of example only, and not limitation. Thus, the breadth and scope of this disclosure should not be limited by any of the above-described exemplary embodiments. Moreover, any combination of the above-described éléments in ail possible variations thereof is encompassed by the disclosure unless otherwise indicated herein or otherwise clearly contradicted by context.

Additionally, while the processes described above and illustrated in the drawings are shown as a sequence of steps, this was done solely for the sake of illustration. Accordingly, it is contemplated that some steps may be added, some steps may be omitted, the order of the steps may be re-arranged, and some steps may be performed in parallel.

Claims

1. A method for decoding a picture, the method comprising:

decoding information that the picture is partitioned into more than one segment based on one or more syntax éléments in a bitstream;

decoding information that a spatial segmentation is uniform based on the one or more syntax éléments in the bitstream;

determining a segment unit size based on the one or more syntax éléments or based on a predefined segment unit size;

decoding a first value indicating a segment width from one or more code words in the bitstream;

decoding a second value indicating a segment height from the one or more code words in the bitstream;

deriving segment column widths based on a picture width in number of segment units and the first value, wherein deriving segment column widths comprises setting column width values of ail segment columns in the picture except one column equal to the first value, and setting the column width value of the one remaining segment column equal to the picture width minus the sum of the width values of ail segment columns except the one segment column;

deriving segment row heights based on a picture height in number of segment units and the second value, wherein deriving segment row heights comprises setting row height values of ail segment rows in the picture except one row equal to the second value, and setting the row height value of the one remaining segment row equal to a picture height minus the sum of the height values of ail segment rows except the one segment row;

deriving a spatial location for a current block based on the derived segment column widths and the derived segment row heights; and decoding the current block based on the derived spatial location.

2. The method of claim 1, wherein the one or more syntax éléments is located in a picture parameter set.

3. The method of any one of claims 1-2, wherein the one or more syntax éléments comprises a one-bit flag specifying whether the spatial segmentation is uniform.

4. The method of any one of claims 1-3, wherein a segment unit is a coding tree unit or a coding tree block.

5. The method of any one of claims 1-4, further comprising calculating the size of the picture in number of segment units.

6. The method claim 5, wherein calculating the size of the picture in number of segment units comprises: calculating the size of the picture segment for the height and calculating the size of the picture segment for the width.

7. The method of any one of claims 1-6, wherein the first value represents a tile width in segment units, and the second value represents a tile height in segment units.

8. The method of any one of claims 1-7, wherein decoding the first value from one or more code words in the bitstream consists of decoding a value of a particular code word in the bitstream and adding 1 to the decoded value, and/or decoding the second value from one or more code words in the bitstream consists of decoding a value of a second particular code word in the bitstream and adding 1 to the decoded value.

9. The method of any one of claims 1-8, wherein deriving segment column widths comprises: comparing a value equal to (A - TileWidth) to TileWidth, wherein TileWidth is equal to the first value, and A is equal to a remaining width value, and/or deriving segment row heights comprises: comparing a value equal to (A - TileHeight) to TileHeight, wherein TileHeight is equal to the second value, and A is equal to a remaining height value

10. The method of claim 9, wherein the remaining width value is equal to said picture width, and/or the remaining height value is equal to said picture height.

11. The method of claim 9 or 10, wherein if it is determined that the value of (A - TileWidth) is greater than TileWidth, then performing the steps of: setting a first column width variable equal to TileWidth; and comparing a value equal to (A - (2 x TileWidth)) to TileWidth, and/or if it is determined that the value of (A - TileHeight) is greater than TileHeight, then performing the steps of: setting a first row height variable equal to TileHeight; and comparing a value equal to (A - (2 x TileHeight)) to TileHeight.

12. The method of claim 9, 10, or 11, wherein comparing the value (A - TileWidth) to TileWidth comprises: setting A equal to (A TileWidth); and comparing A with TileWidth, and/or comparing the value (A - TileHeight) to TileHeight comprises: setting A equal to (A TileHeight); and comparing A with TileHeight.

13. A computer program comprising instructions which when executed by processing circuitry causes the processing circuitry to perform the method of any one of claims 1-12.

14. A carrier containing the computer program of claim 13, wherein the carrier is one of an electronic signal, an optical signal, a radio signal, and a computer readable storage medium.

15. A decoding apparatus for decoding a picture, the decoding apparatus being configured to perform the method of any one of claims 1-12.

16. A decoding apparatus for decoding a picture, the decoding apparatus comprising:

a computer readable storage medium; and processing circuitry coupled to the computer readable storage medium, wherein the processing circuitry is configured to cause the decoding apparatus to perform the method of any one of claims 1-12.