RU2784930C1 - Low latency image encoding - Google Patents

Abstract

FIELD: image data processing.

SUBSTANCE: invention relates to low latency image encoding/decoding. Method for restoring an image from a data stream includes the stage of decoding slices from a data stream in accordance with the order of slices, and the method reacts to a segment of the syntactic element in the current slice from said slices so as to decode the current slice in accordance with one of at least two modes. In accordance with the first mode, the current slice is decoded from the data stream using context-adaptive entropy decoding, including the output of contexts through the boundaries of slices, continuous updating of context symbol probabilities, and initialisation of symbol probabilities depending on the stored states of symbol probabilities of a previously decoded slice, and prediction decoding through the boundaries of slices. In accordance with the second mode, the current slice is decoded from the data stream using context-adaptive entropy decoding with context output limitation so as not to cross the boundaries of slices, continuous updating of context symbol probabilities and initialisation of symbol probabilities independently of the previously decoded slice, and prediction decoding with prediction decoding limitation so as not to cross the boundaries of slices.

EFFECT: invention provides effective parallelisation.

10 cl, 37 dwg, 4 tbl

Description

The present invention relates to low latency image coding.

The current HEVC (High Efficiency Video Coding) scheme contains slices, entropy slices (formerly lightweight slices), tiles, and wave parallel processing (WPP) as tools for parallelization.

For parallelizing video encoders and decoders, image-level partitioning has several advantages over other approaches. In previous video codecs like H.264/AVC [1], image splits were only possible with regular slices at a high cost in terms of coding efficiency. For scalable parallel H.264/AVC decoding, it is necessary to combine macroblock-level parallelism for image reconstruction and frame-level parallelism for entropy decoding. This approach, however, provides a limited reduction in image latency and high memory usage. To overcome these limitations, new image splitting strategies have been included in the HEVC codec. The current reference software release (HM-6) contains 4 different approaches: regular or normal slices, entropy slices, wave parallel processing (WPP) substreams, and tiles (non-overlapping images). Typically, these picture partitions contain a set of largest coding units (LCUs) or, in a synonymous formulation, coding tree units (CTUs) as defined in HEVC, or even a subset of them.

FIG. 1 shows a picture 898 exemplarily arranged in a regular slice 900 per row 902 of LCUs or macroblocks in a video frame. Regular or normal slices (as defined in H.264 [1]) have the most coding degradation since they violate entropy decoding and prediction dependencies.

Entropy slices, like slices, break entropy decoding dependencies but allow prediction (and filtering) to cross slice boundaries.

In WPP, image partitions are line-interleaved and prediction is allowed to use data from blocks in other partitions. In this way, coding loss is minimized while wave parallelism can be applied at the same time. Interleaving, however, violates the causality of the bitstream, since the previous split needs the next split to be decoded.

Figure 2, as an example, depicts the image 898, divided into two rows 904, 904b tiles 906 horizontal split. Tiles define horizontal 908 and vertical borders 910, which divide image 898 into columns 912a, b, c and rows 904a, b of tiles. Like regular slices 900, tiles 906 violate entropy decoding and prediction dependencies but do not require a header for each tile.

For each of these methods, the number of splits can be freely chosen by the encoder. Usually, the existence of more partitions results in more compression loss. However, with WPP, the loss propagation is not as high, and therefore the number of image splits can even be fixed at one per line. This also leads to several benefits. First, for WPP, bitstream causality is guaranteed. Second, decoder implementations may assume that some amount of parallelism is available, which also improves resolution. Finally, none of the context selection and prediction dependencies should be violated when decoding in wave order, resulting in relatively low coding loss.

However, to date, all principles of parallel coding in the transform do not achieve high compression efficiency in combination with low delay. This is also true for the WPP principle. Slices are the smallest transport units in the encoding pipeline, and multiple WPP substreams must still be transported sequentially.

Therefore, it is an object of the present invention to provide an image coding principle that enables parallel decoding according to, for example, wave parallel processing with increased efficiency, such as further reducing end-to-end delay or increasing coding efficiency by reducing encoding overhead.

This objective is achieved by the subject matter of the independent claims.

The main discovery of the present invention is that parallel processing principles, such as wave parallel processing, can be implemented with reduced end-to-end delay, by abandoning the conventional slice principle, according to which slices are either encoded/decoded completely independently of image areas outside the corresponding slice, or at least independently of areas outside the corresponding slice, as far as entropy coding is concerned, in favor of slices of different kinds, namely slices called dependent slices that take into account interdependencies across slice boundaries, and other slices that do not take into account, called, for example, normal slices.

Another major finding of the present invention, which may be combined with the former or used alone, is that the WPP processing principle can be made more efficient if slice start syntaxes are used to locate WPP entry points.

Preferred embodiments of the present application are described below with respect to the figures, useful embodiments being the subject of the dependent claims. On the figures:

Fig. 1 shows an image sliced, as an example, into a regular slice per line of LCUs or macroblocks in the image;

figure 2 depicts an image divided, as an example, into two rows of horizontally split tiles;

3 depicts, by way of example, the assignment of parallel-coded partitions to a slice or network transport segment;

4 is a schematic diagram illustrating generalized frame fragmentation by the minimum end-to-end delay tile encoding approach;

5 is a schematic diagram illustrating exemplary frame fragmentation by WPP coding approach for minimum end-to-end delay;

Fig. 6 is a schematic block diagram illustrating a conversion scenario using video services;

7 illustrates schematically possible coding, transmission, and decoding timing for tiles with generalized subsets with minimum end-to-end delay;

Fig. 8 schematically depicts timing that typically achieves end-to-end delay;

Fig. 9 illustrates an image having 11×9 coding tree blocks as an example, which is divided into two slices;

Fig. 10 illustrates an image having 13×8 coding tree blocks as an example, which is divided into three tiles;

Fig. 11 shows an example of a sequence parameter set syntax;

Fig.12 depicts an example of the syntax of the set of image parameters;

Fig. 13 shows an example slice header syntax;

Fig. 14 exemplifies the partitioning of an image for WPP processing into a regular slice and, for low latency processing, into dependent slices;

Fig. 15 shows an example for a region in the image parameter set syntax;

16 shows a possible slice header syntax;

17 schematically illustrates coding relationships for normal slices (and dependent slices);

18 is a schematic diagram comparing coding for low latency tile transport (wave parallel processing using dependent slices);

Fig. 19 illustrates temporal scheduling illustrating exemplary WPP low latency pipelining coding using wave parallel processing using dependent slices as shown on the right side of Fig. 18;

Fig. 20 is a schematic diagram illustrating the improvement in robustness by using regular slices as anchors;

Fig. 21 depicts another embodiment for slice header syntax;

Fig. 22 depicts another embodiment for a picture parameter set syntax;

Fig. 23 is a schematic diagram illustrating the process of initializing the symbol probabilities for the dependent slice in the case of starting at the left border of the image;

Fig. 24 is a schematic representation of a decoder;

Fig. 25 is a schematic block diagram of a decoder along with a schematic illustration of the partitioning of an image into coding blocks and slices;

Fig. 26 is a schematic block diagram of an encoder;

Fig. 27 schematically depicts an image divided into normal and dependent slices, referred to here as slice segments;

Fig.28a and 28b schematically depict the image, divided into normal and dependent slices, referred to here as slice segments, on the one hand, and tiles, on the other hand;

29 is a flowchart illustrating a context initialization process using dependent slices;

Fig.30 depicts a flowchart illustrating the process of saving the context for the use of dependent slices; and

31 schematically depicts different WPP entry point signaling capabilities.

In the following, the description begins with a description of current principles for enabling parallel image processing and low latency coding, respectively. The problems involved in wanting to have both options are briefly outlined. In particular, as will appear from the following description, the principle of WPP substreams as proposed so far conflicts in one way or another with the desire to have low latency due to the need to transmit WPP substreams by grouping them into one slice. The following embodiments introduce parallel processing principles, such as the WPP principle, applied in applications requiring even lower latency by extending the slice principle, namely by introducing another type of slice, later called dependent slices.

Minimizing end-to-end video latency from capture to display is one of the main goals in applications such as video conferencing and the like.

The signal processing chain for digital video transmission consists of a camera, capture device, encoder, encapsulation, transmission, demultiplexer, decoder, renderer and display. Each of these stages contributes to the end-to-end delay by buffering the image data before passing it in sequence to the next stage.

Some applications require this delay to be minimized, such as remote manipulation of objects in hazardous areas without direct line of sight of the object being manipulated, or minimally invasive surgery. Even a short delay can lead to serious difficulties in proper manipulation or even lead to catastrophic errors.

In many cases, the entire video frame is buffered during the processing step, for example, to enable intra-frame processing. Some stages collect data to form packets that are sent to the next stage. Typically, there is a lower bound on latency that results from local processing requirements. This is analyzed for each individual stage in more detail below.

In-camera processing does not necessarily require intra-frame signal processing, so the minimum latency is determined by the integration time of the sensor, which is limited by the frame rate and some design decisions of the hardware manufacturer. The camera output is usually related to the scan order, which typically starts processing at the top left corner, moves to the top right corner, and continues line by line to the bottom right corner. Therefore, it takes about one frame duration until all data has been transferred from the sensor to the camera output.

The capture device can send camera data directly after receiving; however, it typically buffers some data and generates bursts to optimize data access for memory or storage. In addition, the connection between the camera/capture device and the computer's memory typically limits the data rate to direct the captured image data to the memory for further processing (encoding). Typically cameras are connected via Universal Serial Bus (USB) 2.0 or soon USB 3.0, which always includes a partial transport of image data to the encoder. This limits the possibility of parallelization on the encoder side in scenarios with extremely low latency, i.e. the encoder tries to start encoding as soon as possible when data becomes available from the camera, for example in order to scan the raster from the top to the bottom of the image.

There are some degrees of freedom in the encoder that allow a trade-off decision on coding efficiency, in relation to the data rate necessary for some fidelity of video playback, to reduce processing delay.

The encoder uses the data that has already been sent to predict the image to be encoded. Typically, the difference between the actual image and the prediction may be encoded with fewer bits than would be required without the prediction. These prediction values must be available at the decoder, so the prediction is based on previously decoded portions of the same picture (intra-picture prediction) or on other pictures (inter-picture prediction) that have been processed before. Video coding standards before HEVC use only the portion of the image above or on the same line but to the left - which were previously encoded - for intra-frame prediction, motion vector prediction, and entropy coding (Context Adaptive Binary Arithmetic Coding (CABAC)).

In addition to optimizing the prediction structure, the impact of parallel processing can be taken into account. Parallel processing requires the identification of image areas that can be processed independently. For practical reasons, adjacent areas are chosen, such as horizontal or vertical rectangles, which are often referred to as "tiles". In the case of low latency constraints, these areas should allow parallelized encoding of the data from the memory capture device to be performed as soon as possible. Assuming the contents of a raster scan memory are being sent, it makes sense to vertically split the raw data to start encoding immediately. Within such tiles that divide the image into vertical partitions (cf. the figure below), intra prediction, motion vector prediction, and entropy coding (CABAC) can result in acceptable coding efficiency. To minimize latency, only a portion of the image, starting at the top, is transferred to the encoder's frame memory, and parallel processing should start in vertical tiles.

Another way to enable parallel processing is to use WPP in a regular slice that will be compared against tiles, a "string" of tiles included in a single slice. The data in that slice can also be encoded in parallel using WPP substreams within the slice. The division of the image into slices 900 and WPP tiles/substreams 914 is shown as examples in FIG. 3/1.

3 thus depicts the assignment of parallel coded partitions, such as 906 or 914, to a slice or network transport segment (single network packet or multiple network 900 packets).

Encapsulating the encoded data into Network Abstraction Layer (NAL) units as defined in H.264 or HEVC, before transmission or during the encoding process, adds some header to the data blocks that allows each block to be identified and the blocks to be reordered, if applicable. In the standard case, no additional signaling is required, since the order of encoding elements is always in decoding order, i.e., an explicit assignment of the position of a tile or a common encoding fragment is determined.

If parallel processing is considered with an additional transport layer for low latency parallel transport, i.e. the transport layer may reorder the image partitions for tiles to allow for low latency transmission, meaning fragments are broadcast as shown in FIG. 4 when they are encoded. These fragments may also be incompletely encoded slices, they may be a subset of a slice, or they may be contained in a dependent slice.

In the case of creating additional chunks, there is a trade-off between efficiency, which is greatest with large data blocks, since the header information adds a constant number of bytes, and latency, since large data blocks of parallel encoders must be buffered before transmission. The overall delay can be reduced if the encoded representation of the vertical tiles 906 is divided into a number of fragments 916, which are transmitted as soon as the fragment is completely encoded. The size of each fragment may be determined based on a fixed image area such as macroblocks, LCUs, or based on maximum data as shown in FIG.

4 thus depicts a generalized frame fragmentation by a minimum end-to-end delay tile encoding approach.

Similarly, FIG. 5 depicts frame fragmentation with the WPP coding approach for minimum end-to-end delay.

The transmission may add additional delay, for example, if additional block-oriented processing is applied, such as forward error correction codes, which increase the robustness of the transmission. Also, the network infrastructure (routers, etc.) or the physical layer can add latency, this is commonly known as connection latency. In addition to latency, the transmission bit rate determines the time (delay) for data transfer from Party a to Party b in a conversation, as shown in FIG. 6, that uses video services.

If encoded data blocks are transmitted out of order, the reordering delay must be taken into account. Decoding may begin as soon as a data unit arrives, assuming that other data units are available to be decoded before this one.

In the case of tiles, there are no dependencies between tiles, so a tile can be decoded immediately. If tile fragments have been created, such as separate slices per fragment as shown in FIG. 4, the fragments can be directly transported once they have been encoded according to how their contained LCUs or coding units (CUs) have been encoded.

The renderer collects the outputs of the parallel decoding engines and sends the combined image line by line to the display.

The display does not necessarily add any delay, but in practice may perform some intra-frame processing before the image data is actually displayed. It depends on the design decisions of the hardware manufacturer.

In summary, inventors can influence the encoding, encapsulation, transmission, and decoding steps to achieve the lowest end-to-end delay. If the inventors use parallel processing, tiles, and tile fragmentation, the overall latency can be significantly reduced, as shown in Fig. 7, compared to the commonly used processing chain, which adds a delay of about one frame at each of these stages, as shown in Fig. .eight.

In particular, while FIG. 7 depicts encoding, transmission, and decoding for tiles with generalized subsets with minimum end-to-end delay, FIG. 8 illustrates the end-to-end delay typically achieved.

HEVC allows you to use slice splitting, tile splitting and as follows.

tile: An integer number of tree blocks co-occurring in one column and one row, ordered sequentially in the tile tree block raster scan. Dividing each image into tiles is a partition. The tiles in the image are ordered sequentially in the image tile raster scan. Although the slice contains tree blocks that are sequential in the tree block raster scan of the tile, these tree blocks are not necessarily sequential in the image tree block raster scan.

slice: An integer number of tree blocks ordered sequentially in a raster scan. The division of each image into slices is a partition. The tree block addresses are derived from the address of the first tree block in the slice (as represented in the slice header).

Raster scan: Mapping a rectangular 2D pattern onto a 1D pattern so that the first entries in the 1D pattern are made from the first top row of the 2D pattern, scanned from left to right, followed similarly by the second, third, and so on. sample lines (going down), each being scanned from left to right.

tree block: a block of N×N luminance samples and two corresponding blocks of chrominance samples of an image that has three arrays of samples, or an N×N sample block of a monochrome image or an image that is encoded using three separate color planes. Dividing a slice into blocks of a tree is a split.

Partitioning: Dividing a set into subsets such that each element of the set is in exactly one of the subsets.

Quadtree: A tree in which a parent node can be split into four child nodes. A child node can become a parent node for another split into four child nodes.

The following explains the spatial subdivision of images, slices, and tiles. In particular, the following description specifies how an image is divided into slices, tiles, and blocks of the coding tree. Images are divided into slices and tiles. A slice is a sequence of coding tree blocks. Similarly, a tile is a sequence of coding tree blocks.

Samples are processed in units of coding tree blocks. The size of the brightness array for each tree block in both width and height counts is CtbSize. The width and height of the chrominance arrays for each coding tree block are CtbWidthC and CtbHeightC, respectively. For example, an image may be divided into two slices, as shown in the following figure. As another example, the image may be divided into three tiles, as shown in the second following figure.

Unlike slices, tiles are always rectangular and always contain an integer number of coding tree blocks in the coding tree block raster scan. A tile may consist of coding tree blocks contained in more than one slice. Likewise, a slice may contain coding tree blocks contained in more than one tile.

Fig.9 illustrates the image 898 with 11 to 9 blocks 918 of the coding tree, which is divided into two slices 900a, b.

10 illustrates a 13 by 8 coding tree block 918 image that is partitioned into three tiles.

Each block 918 of the coding tree 898 is assigned a split signaling to identify block sizes for intra or inter prediction and for transform coding. The partition is a recursive quadtree partition. A quadtree root is associated with an encoding tree block. The quadtree is split until a leaf is reached, which is referred to as a coding block. The coding block is the root node of two trees, the prediction tree and the transformation tree.

The prediction tree defines the position and size of the prediction blocks. The prediction blocks and associated prediction data are referred to as a prediction unit.

11 depicts an exemplary RBSP syntax for a sequence parameter set.

The transformation tree defines the position and size of the transformation blocks. Transformation units and associated transformation data are referred to as a transformation unit.

The partitioning information for luma and chrominance is the same for the prediction tree, and may or may not be the same for the transformation tree.

The coding unit, the associated coding data, and the associated prediction and transformation units together form a coding unit.

The process for converting the coding tree block address in coding tree block raster order to tile scan order can be as follows:

The outputs of this process are

- array CtbAddrTS[ctbAddrRS] with ctbAddrRS ranging from 0 to PicHeightInCtbs * PicWidthInCtbs-1 inclusive.

- TileId[ctbAddrTS] array with ctbAddrTS ranging from 0 to PicHeightInCtbs * PicWidthInCtbs-1 inclusive.

The CtbAddrTS[] array is output as follows:

The TileId[] array is output like this:

Corresponding exemplary syntax is shown in FIGS. 11, 12, and 13, with FIG. 12 having an exemplary RBSP syntax of a set of image parameters. 13 depicts an exemplary slice header syntax.

In the example syntax, the following semantics may apply:

entropy_slice_flag equal to 1 specifies that the value of the slice header syntax elements not present is assumed to be equal to the value of the slice header syntax elements in the preceding slice, where the preceding slice is defined as the slice containing the encoding tree block with location (SliceCtbAddrRS-1). entropy_slice_flag must be 0 when SliceCtbAddrRS is 0.

tiles_or_entropy_coding_sync_idc equal to 0 specifies that there is only one tile in each picture in the encoded video sequence, and no particular synchronization process is called for context variables before decoding the first coding tree block of the coding tree block string.

tiles_or_entropy_coding_sync_idc equal to 1 specifies that there can be more than one tile in each picture in the encoded video sequence, and no particular synchronization process is called for context variables before decoding the first coding tree block of the coding tree block row.

tiles_or_entropy_coding_sync_idc equal to 2 specifies that there is only one tile in each picture in the encoded video sequence, the specific synchronization process for context variables is called before decoding the first coding tree block of a line of coding tree blocks, and the specific memory process for context variables is called after decoding two blocks of the coding tree of a line coding tree blocks.

tiles_or_entropy_coding_sync_idc must be between 0 and 2 inclusive.

num_tile_columns_minus1 plus 1 specifies the number of tile columns that split the image.

num_tile_rows_minus1 plus 1 specifies the number of tile rows that split the image.

When num_tile_columns_minus1 is 0, num_tile_rows_minus1 must not be 0.

One or both of the following conditions must be met for each slice and tile:

- All encoded blocks in a slice belong to the same tile.

- All encoded blocks in a tile belong to the same slice.

NOTE - Within the same image, there can be both slices that contain multiple tiles and tiles that contain multiple slices.

uniform_spacing_flag equal to 1 specifies that column borders, and likewise row borders, are evenly spaced across the image. uniform_spacing_flag equal to 0 specifies that column borders, and likewise row borders, are not uniformly spaced across the image, but are signaled unambiguously using the column_width[i] and row_height[i] syntax elements.

column_width[i] specifies the width of the i-th tile column in coding tree block units.

row_height[i] specifies the height of the i-th row of the tile in units of coding tree blocks.

The ColumnWidth[i] values specifying the width of the i-th tile column in units of coding tree blocks and the ColumnWidthInLumaSamples[i] values specifying the width of the i-th tile column in units of luma samples are output as follows:

The RowHeight[i] values that specify the height of the i-th row of the tile in units of coding tree blocks are output as follows:

Values ColBd[i], specifying the location of the left border of the column of the i-th column of the tile in units of blocks of the coding tree, are output as follows:

The RowBd[i] values specifying the location of the top row boundary of the i-th row of the tile in units of coding tree blocks are output as follows:

num_substreams_minus1 plus 1 specifies the maximum number of substreams included in a slice when tiles_or_entropy_coding_sync_idc is 2. When it is not present, it is concluded that the value of num_substreams_minus1 is 0.

num_entry_point_offsets specifies the number of entry_point_offset[i] syntax elements in the slice header. When tiles_or_entropy_coding_sync_idc is 1, num_entry_point_offsets must be in the range 0 to (num_tile_columns_minus1 + 1) * (num_tile_rows_minus1 + 1) - 1 inclusive. When tiles_or_entropy_coding_sync_idc is 2, num_entry_point_offsets must be in the range 0 to num_substreams_minus1 inclusive. When not present, the value of num_entry_point_offsets is assumed to be 0.

offset_len_minus1 plus 1 specifies the length in bits of entry_point_offset[i] syntax elements.

entry_point_offset[i] specifies the offset of the i-th entry point in bytes and shall be represented by offset_len_minus1 plus 1 bits. A slice NAL coded unit consists of num_entry_point_offsets + 1 subsets, with subset index values ranging from 0 to num_entry_point_offsets inclusive. Subset 0 consists of bytes 0 to entry_point_offset[0] - 1 inclusive, of the slice NAL coded unit, subset k, with k in the range 1 to num_entry_point_offsets - 1 inclusive, consists of bytes entry_point_offset[k-1] to entry_point_offset[k ] + entry_point_offset[k-1] - 1, inclusive, of the slice NAL coded unit, and the last subset (with subset index equal to num_entry_point_offsets) consists of the remaining bytes of the slice NAL coded unit.

NOTE – The NAL unit header and the slice header of the coded slice NAL unit are always included in subset 0.

When tiles_or_entropy_coding_sync_idc is 1 and num_entry_point_offsets is greater than 0, each subset must contain all of the encoded bits of one or more completed tiles, and the number of subsets must be equal to or less than the number of tiles in the slice.

When tiles_or_entropy_coding_sync_idc is equal to 2 and num_entry_point_offsets is greater than 0, the subset k for each of all possible values of k shall contain all the bits to be used during the initialization process for the current bitstream pointer k.

With regard to slice data semantics, the following may apply.

end_of_slice_flag equal to 0 specifies that another macroblock in the slice follows.

end_of_slice_flag equal to 1 specifies the end of the slice and that no other macroblock follows.

entry_point_marker_two_3bytes is a fixed value sequence of 3 bytes equal to 0x000002. This syntax element is called the entry token prefix.

tile_idx_minus_1 specifies the TileID in raster scan order. The first tile in the image must have a TileID of 0. The value of tile_idx_minus_1 must be between 0 and (num_tile_columns_minus1 + 1) * ( num_tile_rows_minus1 + 1) - 1.

The CABAC parsing process for slice data can be as follows:

This process is invoked when parsing syntax elements with descriptor ae(v).

The inputs to this process are the request for the value of the syntax element and the value of the parsed syntax elements.

The output of this process is the value of the syntax element.

At the start of parsing slice data in a slice, the CABAC parsing process initialization process is called. When tiles_or_entropy_coding_sync_idc is equal to 2 and num_substreams_minus1 is greater than 0, a BitStreamTable mapping table with num_substreams_minus1 + 1 elements specifying a bitstream pointer table to use for subsequent derivation of the current bitstream pointer is output as follows.

- BitStreamTable[0] is initialized to contain a bitstream pointer.

- For all indices i greater than 0 and less than num_substreams_minus1 + 1, BitStreamTable[i] contains the bitstream pointer entry_point_offset[i] bytes after BitStreamTable[i-1].

The current bitstream pointer is set to BitStreamTable[0].

The address of the minimum coding block of the coding tree block containing the spatial neighboring block T, ctbMinCbAddrT, is derived using the location (x0, y0) of the upper left luma value of the current coding tree block, for example, as follows.

The availableFlagT variable is obtained by calling the appropriate coding block availability output process with ctbMinCbAddrT as input.

At the start of parsing the coding tree and tiles_or_entropy_coding_sync_idc is equal to 2 and num_substreams_minus1 is greater than 0, the following applies.

- If CtbAddrRS % PicWidthInCtbs is 0, the following applies.

- When availableFlagT is equal to 1, the CABAC parsing process synchronization process is called, as defined in the "Synchronization Process for Context Variables" subclause.

- The decoding process for binary decisions is called before completion, followed by the initialization process for the arithmetic decoding engine.

- The current bitstream pointer is set to pointing to BitStreamTable[i] with index i output as follows.

i=(CtbAddrRS/PicWidthInCtbs) % (num_substreams_minus1 + 1)

- Else, if CtbAddrRS % PicWidthInCtbs is equal to 2, the CABAC parsing process store process is invoked as specified in the Memory Process for Context Variables subclause.

The initialization process can be as follows:

The outputs of this process are initialized by CABAC internal variables.

Its special processes are called when parsing slice data in a slice starts, or when parsing encoding tree data starts, and the encoding tree is the first encoding tree in a tile.

The memorization process for context variables can be as follows:

The inputs to this process are CABAC context variables indexed by ctxIdx.

The output of this process is the TableStateSync and TableMPSSync variables containing the values of the m and n variables used in the process of initializing the context variables that are assigned to the syntax elements, except for the end-of-slice flag.

For each context variable, the corresponding elements n and m of the TableStateSync and TableMPSSync tables are initialized to the corresponding pStateIdx and valMPS.

The synchronization process for context variables can be as follows:

The inputs to this process are the variables TableStateSync and TableMPSSync containing the values of the variables n and m used in the process of storing the context variables that are assigned to the syntax elements, except for the slice end flag.

The outputs of this process are CABAC context variables indexed by ctxIdx.

For each context variable, the corresponding context variables pStateIdx and valMPS are initialized to the corresponding elements n and m of the TableStateSync and TableMPSSync tables.

The following explains low-latency encoding and transport using WPP. In particular, the description below shows how low latency transport as described in FIG. 7 can also be applied to WPP.

First, it is important that a subset of the image can be sent before the entire image is completed. Normally, this is achieved using slices, as already shown in Fig.5.

To reduce latency compared to tiles, as shown in the following figures, it is necessary to apply a single WPP subflow per LCU row and additionally allow each of these rows to be transmitted separately. To keep encoding efficiency high, slices per line/substream cannot be used. Therefore, the so-called dependent slice defined in the next section is introduced below. This slice, for example, does not have all the fields of the full HEVC slice header, but the fields used for entropy slices. Also, there may be a switch to disable the CABAC break between lines. In the case of WPP, the use of the CABAC context (arrows in FIG. 14) and row prediction must be enabled in order to maintain the WPP coding efficiency gain over tiles.

In particular, FIG. 14 exemplifies an image 10 for WPP into regular slice 900 (reg. SL), and for low latency processing into dependent slices (OS) 920.

Currently, the forthcoming HEVC standard proposes two types of partitioning in relation to slices. There is a regular (normal) slice and an entropy slice. A regular slice is a completely independent slice of an image, with the exception of some dependencies that may be exposed due to the deblocking filter process on slice boundaries. Entropy slice is also independent, but only with respect to entropy coding. The idea of Fig. 14 is a generalization of the principle of slice formation. Thus, the upcoming HEVC standard should offer two general types of slices: independent (regular) or dependent. Therefore, a new type of slice is introduced, the dependent slice.

A dependent slice is a slice that has dependencies on a previous slice. Dependencies are specific data that can be used between slices in the entropy decoding process and/or in the pixel reconstruction process.

14 shows the principle of dependent slices as an example. The image starts, for example, always with a regular slice. Note that the behavior of a regular slice is slightly modified in this principle. Typically, in standards like H.264/AVC or HEVC, a regular slice is a completely independent slice and there is no need to store any data after decoding except for some data for the deblocking filter process. But the processing of the upcoming dependent slice 920 is only possible by referring to the slice data above, in this case in the first row: the regular slice 900. To establish this, the regular slices 900 must store the data of the last CU row.

This data contains:

- data of the CABAC coding mechanism (the state of the context model of one CU, from which the dependent slice entropy decoding process can be initialized),

- all decodable CU syntax elements for the regular CABAC decoding process of dependent CUs,

- intra prediction and motion vector prediction data.

Therefore, each dependent slice 920 must perform the same procedure of storing data for the next dependent slice in the same picture.

In practice, these additional steps should not be a problem, since the decoding process is usually always forced to store some data like syntax elements.

The sections below present possible changes to the syntax of the HEVC standard that are necessary to make the dependent slice principle possible.

5, for example, illustrates possible changes to the RBSP syntax of a picture parameter set.

The semantics of a set of image parameters for dependent slices can be as follows:

dependent_slices_present_flag equal to 1 specifies that the picture contains dependent slices, and the decoding process of each (regular or dependent) slice shall store entropy decoding states and intra-prediction and motion-vector prediction data for the next slice, which may be a dependent slice, which may also follow a regular slice. The next dependent slice can refer to this stored data.

Fig.16 depicts a possible slice_header syntax with changes relative to the current state of HEVC.

dependent_slice_flag equal to 1 specifies that the value of the slice header syntax elements not present is assumed to be equal to the value of the slice header syntax elements in the preceding (regular) slice, where the preceding slice is defined as the slice containing the coding tree block with location (SliceCtbAddrRS - 1). dependent_slice_flag must be 0 when SliceCtbAddrRS is 0.

no_cabac_reset_flag equal to 1 specifies initialization of CABAC from the saved state of the previously decoded slice (and without the original values). Otherwise, i.e. if equal to 0, CABAC initialization is independent of any state of the previously decoded slice, i.e. with original values.

last_ctb_cabac_init_flag equal to 1 specifies initialization of CABAC from the saved state of the last encoded tree block of the previously decoded slice (for example, for tiles always equal to 1). Otherwise, (equal to 0) the initialization data is referenced from the saved state of the second encoded tree block of the last (adjacent) ctb-row previously decoded slice if the first encoded tree block of the current slice is the first encoded tree block in the row (i.e. WPP mode) , otherwise CABAC initialization is performed from the saved state of the last encoded tree block of the previously decoded slice.

Below is a comparison of dependent slices and other (informational) partitioning schemes.

17 shows the difference between normal and dependent slices.

Possible coding and transmission of WPP substreams in dependent slices (DS), as shown with respect to FIG. 18, compares coding for low latency tile transport (left) and WPP/DS (right). The bold continuous crosses in FIG. 18 represent the same point in time for the two methods, assuming that encoding a WPP line takes the same time as encoding a single tile. Due to encoding dependencies, only the first WPP line is ready after all tiles have been encoded. But using the dependent slice approach allows the WPP approach to send the first row if it is encoded. This differs from earlier WPP substream assignments, a "substream" is defined for WPP as concatenation of slice CU rows for WPP decoding by the same decoder stream, i.e. the same core/processor. Although substreaming per row and per entropy slice was also possible previously, entropy slice violates entropy encoding dependencies and therefore has lower encoding efficiency, i.e. the WPP efficiency gain is lost.

Additionally, the delay difference between both approaches can be really low, assuming a transmission as shown in FIG. In particular, FIG. 19 depicts low latency pipelining WPP coding.

Assuming that the coding of the last two CUs from DS #1.1 in the WPP approach of FIG. 18 does not take longer than the transmission of the first line of SL#1, there is no difference between tiles and WPP in case of low delay. But the efficiency of WP/DS coding surpasses the principle of tiles.

To improve robustness for low latency WPP mode, FIG. 20 illustrates that robustness enhancement is achieved by using regular slices (RS) as anchors. In the image shown in FIG. 20, a (regular) slice (RS) is followed by dependent slices (DS). In this case, the (regular) slice acts as a dependency breaking anchor for the previous slices, hence more robustness is provided at such insertion point of the (regular) slice. Basically, this is no different from inserting a (regular) slice anyway.

The principle of dependent slices can also be implemented in the following way.

In this case, FIG. 21 shows a possible slice header syntax.

The semantics of the slice header is as follows:

dependent_slice_flag equal to 1 specifies that the value of each not present slice header syntax element is assumed to be equal to the value of the corresponding slice header syntax element in the preceding slice containing the coding tree block for which the coding tree block address is SliceCtbAddrRS - 1. When not present, it is implied that that the value of dependent_slice_flag is 0. The value of dependent_slice_flag shall be 0 when SliceCtbAddrRS is 0.

slice_address specifies the address in slice granularity resolution at which the slice begins. The length of the slice_address syntax element is (Ceil(Log2(PicWidthInCtbs * PicHeightInCtbs)) + SliceGranularity) bits.

The SliceCtbAddrRS variable specifying the coding tree block in which the slice starts, in the coding tree block raster scan order, is output as follows.

SliceCtbAddrRS = (slice_address >> SliceGranularity

The SliceCbAddrZS variable specifying the address of the first coding block in the slice with the minimum coding block granularity in z-scan order is output as follows.

Slice decoding starts with the largest possible coding unit, or CTU, at the slice start coordinate.

first_slice_in_pic_flag indicates whether the slice is the first slice of an image. If first_slice_in_pic_flag is equal to 1, the variables SliceCbAddrZS and SliceCtbAddrRS are both set to 0, and decoding starts from the first coding tree block in the picture.

pic_parameter_set_id specifies the image parameter set to use. The value of pic_parameter_set_id must be between 0 and 255 inclusive.

num_entry_point_offsets specifies the number of entry_point_offset[i] syntax elements in the slice header. When tiles_or_entropy_coding_sync_idc is 1, num_entry_point_offsets must be in the range 0 to (num_tile_columns_minus1 + 1) * (num_tile_rows_minus1 + 1) - 1 inclusive. When tiles_or_entropy_coding_sync_idc is 2, num_entry_point_offsets must be in the range 0 to PicHeightInCtbs - 1 inclusive. When not present, the value of num_entry_point_offsets is assumed to be 0.

offset_len_minus1 plus 1 specifies the length in bits of entry_point_offset[i] syntax elements.

entry_point_offset [i] specifies the i-th entry point offset in bytes and shall be represented by offset_len_minus1 plus 1 bits. The encoded slice data after the slice header consists of num_entry_point_offsets + 1 subsets, with subset index values ranging from 0 to num_entry_point_offsets inclusive. Subset 0 consists of bytes 0 - entry_point_offset[0] - 1 inclusive of encoded slice data, subset k, with k in the range 1 to num_entry_point_offsets - 1 inclusive, consists of bytes from entry_point_offset[k-1] to entry_point_offset[k] + entry_point_offset [k-1] - 1, inclusive, of slice encoded data, and the last subset (with subset index equal to num_entry_point_offsets) consists of the remaining slice encoded data bytes.

When tiles_or_entropy_coding_sync_idc is 1 and num_entry_point_offsets is greater than 0, each subset must contain all encoded bits of exactly one tile, and the number of subsets (i.e., the value of num_entry_point_offsets + 1) must be equal to or less than the number of tiles in the slice.

NOTE – When tiles_or_entropy_coding_sync_idc is 1, each slice must include either a subset of a single tile (in which case entry point signaling is optional) or an integer number of full tiles.

When tiles_or_entropy_coding_sync_idc is equal to 2 and num_entry_point_offsets is greater than 0, each subset k with k in the range 0 to num_entry_point_offsets - 1 inclusive shall include all encoded bits of exactly one line of coding tree blocks, the last subset (with subset index equal to num_entry_point_offsets) shall contain all encoded bits of the remaining coding blocks included in the slice, in which the remaining coding blocks consist of either exactly one coding tree block line, or a subset of one coding tree block line, and the number of subsets (i.e., the value of num_entry_point_offsets + 1) shall be equals the number of coding tree block rows in the slice, which also counts a subset of one coding tree block row in the slice.

NOTE When tiles_or_entropy_coding_sync_idc is 2, a slice may include a number of coding tree block lines and a subset of a coding tree block line. For example, if a slice includes two and a half lines of coding tree blocks, the number of subsets (i.e. num_entry_point_offsets + 1) should be 3.

The corresponding picture parameter set RBSP syntax may be selected as shown in FIG.

The semantics of an RBSP image parameter set can be as follows:

dependent_slice_enabled_flag equal to 1 specifies the presence of the dependent_slice_flag syntax element in the slice header for encoded pictures referring to a picture parameter set. dependent_slice_enabled_flag equal to 0 specifies the absence of the dependent_slice_flag syntax element in the slice header for encoded pictures referring to a picture parameter set. When tiles_or_entropy_coding_sync_idc is 3, dependent_slice_enabled_flag must be 1.

tiles_or_entropy_coding_sync_idc equal to 0 specifies that there should be only one tile in each image referring to a picture parameter set, there should not be a specific synchronization process for context variables called before decoding the first coding tree block of a string of coding tree blocks in each video frame referencing a parameter set image, and the cabac_independent_flag and dependent_slice_flag values for encoded images referring to a picture parameter set must not both be equal to 1.

Note that when cabac_independent_flag and dependent_slice_flag are both equal to 1 for a slice, the slice is an entropy slice.

tiles_or_entropy_coding_sync_idc equal to 1 specifies that there can be more than one tile in each image referencing an image parameter set, there should not be a specific synchronization process for context variables called before decoding the first coding tree block of a string of coding tree blocks in each image referencing an attribute set images, and the cabac_independent_flag and dependent_slice_flag values for encoded images referring to a picture parameter set must not both be equal to 1.

tiles_or_entropy_coding_sync_idc equal to 2 specifies that there should be only one tile in each image referring to a picture parameter set, a specific synchronization process for context variables must be called before decoding the first coding tree block of a string of coding tree blocks in each image referencing a picture parameter set, and a specific memory process for context variables shall be invoked after decoding two coding tree blocks of a line of coding tree blocks in each picture referring to a picture parameter set, and cabac_independent_flag and dependent_slice_flag values for encoded pictures referring to a picture parameter set shall not both be equal to 1.

tiles_or_entropy_coding_sync_idc equal to 3 specifies that there should be only one tile in each image referring to a picture parameter set, there should not be a specific synchronization process for context variables called before decoding the first coding tree block of a string of coding tree blocks in each image referencing a parameter set picture, and cabac_independent_flag and dependent_slice_flag values for encoded pictures referring to a picture parameter set may both be equal to 1.

When dependent_slice_enabled_flag must be 0, tiles_or_entropy_coding_sync_idc must not be 3.

The bitstream conformance requirement is that the value of tiles_or_entropy_coding_sync_idc must be the same for all picture parameter sets that are activated in the encoded video sequence.

For each slice referring to a picture parameter set, when tiles_or_entropy_coding_sync_idc is 2 and the first coding block in the slice is not the first coding block in the first coding tree block of a coding tree block line, the last coding block in the slice must belong to the same coding tree block line, as the first coding block in the slice.

num_tile_columns_minus1 plus 1 specifies the number of tile columns that split the image.

num_tile_rows_minus1 plus 1 specifies the number of tile rows that split the image.

When num_tile_columns_minus1 is 0, num_tile_rows_minus1 must not be 0. uniform_spacing_flag equal to 1 specifies that column borders and likewise row borders are spaced evenly across the image, uniform_spacing_flag equal to 0 specifies that column borders and likewise row borders are not evenly spaced across the image , but signaled explicitly using the column_width[i] and row_height[i] syntax elements.

column_width [i] specifies the width of the i-th tile column in coding tree block units.

row_height [i] sets the height of the i-th row of the tile in units of coding tree blocks.

The colWidth[i] vector specifies the width of the i-th tile column in coding tree block (CTB) units, with column i ranging from 0 to num_tile_columns_minus1 inclusive.

The vector CtbAddrRStoTS[ctbAddrRS] specifies the interactive mode from CTB address in raster scan order to CTB address in tile scan order, with the ctbAddrRS index ranging from 0 to (picHeightInCtbs*picWidthInCtbs)-1 inclusive.

The vector CtbAddrTStoRS[ctbAddrTS] specifies the interactive mode from CTB address in tile scan order to CTB address in raster scan order, with the ctbAddrRS index ranging from 0 to (picHeightInCtbs*picWidthInCtbs)-1 inclusive.

The TileId[ctbAddrTS] vector specifies the interactive mode from the CTB address in tile scan order to the tile id, with ctbAddrTS ranging from 0 to (picHeightInCtbs*picWidthInCtbs)-1 inclusive.

The values of colWidth, CtbAddrRStoTS, CtbAddrTStoRS, and TileId are output by calling the CTB raster and tile scan dialog process with PicHeightInCtbs and PicWidthInCtbs as inputs, and the output is assigned to colWidth, CtbAddrRStoTS, and TileId.

The ColumnWidthInLumaSamples[i] values that specify the width of the i-th tile column in units of brightness samples are set to colWidth[i]<<Log2CtbSize.

An array of MinCbAddrZS[x][y] specifying the conversational mode from the location (x,y) in units of the minimum coding blocks (CB) to the address of the minimum CB in z-scan order, with x ranging from 0 to picWidthInMinCbs - 1 inclusive, and y is in the range 0 to picHeightInMinCbs - 1 inclusive, is output by calling the Z-scan order array initialization process with Log2MinCbSize, Log2CtbSize, PicHeightInCtbs, PicWidthInCtbs, and the vector CtbAddrRStoTS as inputs, and the output is assigned to MinCbAddrZS.

loop_filter_across_tiles_enabled_flag equal to 1 specifies that loop filtering operations are performed across tile boundaries. loop_filter_across_tiles_enabled_flag equal to 0 specifies that loop filtering operations are not performed across tile boundaries. The loop filtering operations include the deblocking filter, adaptive sample bias, and adaptive loop filter operations. When not present, loop_filter_across_tiles_enabled_flag is assumed to be 1.

cabac_independent_flag equal to 1 specifies that the CABAC decoding of coding blocks in a slice is independent of any state of a previously decoded slice. cabac_independent_flag equal to 0 specifies that the CABAC decoding of the coding blocks in the slice is dependent on the states of the previously decoded slice. When not present, the value of cabac_independent_flag is assumed to be 0.

The inference process for the availability of a coding block with the address of the minimum coding block can be as follows:

The inputs to this process are

- address of the minimum coding block minCbAddrZS in z-scan order

- address of current minimum coding block currMinCBAddrZS in z-scan order

The output of this process is the availability of an coding block with the address of the minimum coding block cbAddrZS in the z-scan order cbAvailable.

NOTE 1 – The availability value is determined when this process is invoked.

NOTE 2 – Any coding block, regardless of its size, is associated with a minimum coding block address, which is the address of the coding block with the minimum coding block size in z-scan order.

- If one or more of the following conditions are true, cbAvailable is set to FALSE.

- minCbAddrZS less than 0

- minCbAddrZS is greater than currMinCBAddrZS

- the coding block with the address of the minimum coding block minCbAddrZS belongs to a different slice than the coding block with the address of the current minimum coding block currMinCBAddrZS, and the dependent_slice_flag of the slice containing the coding block with the address of the current minimum coding block currMinCBAddrZS is equal to 0.

- the coding block with the address of the minimum coding block minCbAddrZS is contained in a different tile than the coding block with the address of the current minimum coding block currMinCBAddrZS.

- Otherwise, cbAvailable is set to TRUE.

The CABAC parsing process for slice data can be as follows:

This process is invoked when parsing some syntax elements with descriptor ae(v).

The inputs to this process are a request for the value of a syntax element and the values of previously parsed syntax elements.

The output of this process is the value of the syntax element.

At the start of parsing slice data in a slice, the initialization process of the CABAC parsing process is called.

23 illustrates how the spatial neighbor block T is used to invoke a coding tree block availability inference process relative to the current coding tree block (informative).

The address of the minimum coding block of the coding tree block containing the spatial neighboring block T (FIG. 23), ctbMinCbAddrT, is derived using the location (x0,y0) of the top-left luma value of the current coding tree block as follows.

The availableFlagT variable is obtained by calling the coding block availability output process with ctbMinCbAddrT as input.

At the start of parsing a given coding tree, the following ordered steps are applied.

The arithmetic decoding engine is initialized as follows.

If CtbAddrRS is slice_address, dependent_slice_flag is 1, and entropy_coding_reset_flag is 0, the following applies.

The CABAC parser synchronization process is called with TableStateIdxDS and TableMPSValDS as input.

The decoding process for binary solutions is invoked before completion, followed by the initialization process for the arithmetic decoding engine.

Otherwise, if tiles_or_entropy_coding_sync_idc is 2 and CtbAddrRS % PicWidthInCtbs is 0, the following applies.

When availableFlagT is 1, the CABAC parser synchronization process is called with TableStateIdxWPP and TableMPSValWPP as input.

The decoding process for binary decisions is called before completion, followed by the process for the arithmetic decoding engine.

When cabac_independent_flag is 0 and dependent_slice_flag is 1, or when tiles_or_entropy_coding_sync_idc is 2, the learning process is applied as follows.

When tiles_or_entropy_coding_sync_idc is 2 and CtbAddrRS % PicWidthInCtbs is 2, the CABAC parsing process memory process is called with TableStateIdxWPP and TableMPSValWPP as output.

When cabac_independent_flag is 0, dependent_slice_flag is 1, and end_of_slice_flag is 1, the CABAC parser process store process is called with TableStateIdxDS and TableMPSValDS as output.

The parsing of syntax elements is done as follows:

For each syntax element value requested, a binarization is output.

The binarization for the syntax element and the sequence of parsed bins determines the flow of the decoding process.

For each syntax element binarization bin that is indexed by the binIdx variable, the context index ctxIdx is output.

For each ctxIdx, the arithmetic decoding process is called.

The resulting sequence (b0...bbinIdx) of the parsed bins is compared to the set of bin strings determined by the binarization process after each bin is decoded. When a sequence matches a string of bins in a given set, the corresponding value is assigned to the syntax element.

In case a syntax element value request is processed for the pcm_flag syntax element and the decoded pcm_flag value is 1, the decoding engine is initialized after decoding any pcm_alignment_zero_bit, num_subsequent_pcm and all pcm_sample_luma and pcm_sample_chroma data.

Thus, the above description shows the decoder shown in Fig.24. This decoder, which is generally denoted by reference numeral 5, reconstructs the picture 10 from the data stream 12 in which the picture 10 is encoded in units of slices 14 into which the picture 10 is divided, the decoder 5 being configured to decode the slices 14 from the data stream 12 according to with order 16 slices. Of course, decoder 5 is not limited to sequential decoding of slices 14. Rather, decoder 5 may use wave parallel processing to decode slices 14, as long as the partitioning of image 10 into slices 14 corresponds to wave parallel processing. Therefore, decoder 5, for example, may be a decoder that is capable of decoding slices 14 in parallel in a staggered manner, starting decoding of slices 14, taking into account the order of 16 slices, to enable waveform processing as described above and also described below.

Decoder 5 responds to syntax element portion 18 in the current slice of slices 14 to decode the current slice in accordance with one of at least two modes 20 and 22. In accordance with the first of the at least two modes, namely mode 20, the current slice is decoded from the data stream 12 using context-adaptive entropy decoding, including inferring context across slice boundaries, i. e. through the dotted lines in FIG. 24, i. e. by using the information resulting from the encoding/decoding of other "previous slices in order of 16 slices". In addition, decoding the current slice from the data stream 12 using the first mode 20 comprises continuously updating the codec symbol probabilities and initializing the symbol probabilities at the start of decoding the current slice, which depends on the previously decoded slice's stored symbol probability states. Such a dependency has been described above, for example, in connection with the "synchronization process for codec variables". Finally, the first mode 20 also includes cross-slice prediction decoding. Such slice boundary prediction decoding, for example, may include intra slice boundary prediction, i. e. predicting sample values in the current slice based on already recovered "order 16 in slice" sample values, the previous slice, or prediction of coding parameters across slice boundaries, such as prediction of motion vectors, prediction modes, coding modes, or the like.

According to the second mode 22, the decoder 5 decodes the current slice, i. e. the slice currently to be decoded from data stream 12 using context-adaptive entropy decoding, however, constraining the output of contexts so as not to cross slice boundaries. If ever, for example, the neighbor position template used to infer context for some syntax element related to a block in the current slice extends into the neighboring slice, thus crossing the slice boundary of the current slice, the corresponding attribute of the corresponding section of the neighboring slice, such as the value of the corresponding syntax element of that adjacent section of the adjacent slice is set to the default value to block interdependencies between the current slice and adjacent slices. Although the continuous updating of the symbol probabilities of the contexts may occur exactly as it does in the first mode 20, the initialization of the symbol probabilities in the second mode 22 is independent of any early decoded slice. In addition, predictive decoding is performed with predictive decoding constrained so as not to cross slice boundaries.

To facilitate understanding of the description of FIG. 24 and the following description, reference is made to FIG. 25, which depicts a possible implementation of the decoder 5 in a more constructive sense than compared to FIG. As is the case in FIG. 24, decoder 5 is a predictive decoder using context adaptive entropy decoding to decode the data stream to obtain, for example, prediction residual and prediction parameters.

As shown in FIG. 25, decoder 5 may include an entropy decoder 24, a dequantizer and inverse transform module 26, a combiner 28 implemented as shown in FIG. 25, for example, as an adder, and a predictor 28. Entropy decoder 24, module 26 and the adder 27 are connected in series between the input and output of the decoder 5 in the order they are mentioned, and the predictor 28 is connected between the output of the adder 28 and its other input to form a prediction loop with the combiner 27. Therefore, the decoder 24 has its output additionally connected to the parameters input predictor coding 28.

Although Fig. 25 gives the impression that the decoder sequentially decodes the current picture, decoder 5 may, for example, be implemented to decode picture 10 in parallel. The decoder 5, for example, may contain multiple cores, each operating in accordance with elements 24-28 in Fig.25. Parallel processing, however, is optional and the serial decoder 5 is also capable of decoding the data stream input to the entropy decoder 24.

In order to effectively achieve the aforementioned ability to either sequentially or parallel decode the current picture 10, the decoder 5 operates in units of coding blocks 30 to decode the picture 10. The coding blocks 30, for example, are leaf blocks into which coding tree blocks or largest coding blocks 32 are divided. through a recursive multitree partitioning such as a quadtree partitioning. The coding tree blocks 32, in turn, may be regularly arranged in columns and rows to form a regular partition of the image 10 into these coding tree blocks 32. In FIG. 25, coding tree blocks 32 are shown with continuous lines, while coding blocks 30 are shown with dotted lines. For purposes of illustration, only one coding tree block 32 is shown further broken down into coding blocks 30, while the other coding tree blocks 32 are shown without further splitting to instead directly form a coding block. The data stream 12 may contain a syntax section signaling how the image 10 is divided into coding blocks 30 .

The data stream 12 transmits, for each encoding unit 30, syntax elements that indicate how modules 24-28 are to reconstruct the image content in that encoding unit 30. For example, these syntax elements contain:

1) optionally, split data further splitting the coding block 30 into prediction blocks,

2) optionally, split data further splitting the coding block 30 into residual and/or transform blocks,

3) prediction mode signaling which prediction mode should be used to output the prediction signal for coding block 30, the granularity with which this prediction mode is signaled may depend on coding blocks 30 and/or prediction block.

4) The prediction parameters may be signaled to a coding block or, if present, to a prediction block with the type of prediction parameters sent depending on, for example, the prediction mode. Possible prediction modes, for example, may include intra prediction and/or inter prediction.

5) Other syntax elements may also be present, such as filtering information for filtering image 10 in encoding unit 30 to obtain a prediction signal and/or a reconstructed signal to be reproduced.

6) Finally, information about the remainder in the form of, among other things, the transformation coefficients may be contained in the data stream for block 30 coding; in units of residual blocks, residual data can be signaled; per residual block, spectral decomposition, for example, can be performed in units of the above transformation blocks, if present.

The entropy decoder 24 is responsible for obtaining the aforementioned syntax elements from the data stream. To this end, entropy decoder 24 uses context adaptive entropy decoding. Those. entropy decoder 24 provides several kinds of context. In order to derive a certain syntax element from the data stream 12, the entropy decoder 24 selects a certain context from among the possible contexts. The selection from among the possible contexts is performed depending on the neighborhood attribute of the image area 10 to which the current syntactic context belongs. For each of the possible contexts, entropy decoder 24 controls the symbol probabilities, i. a probability estimate for each possible character from the character alphabet based on the one on which the entropy decoder 24 operates. "Control" includes the aforementioned continuous updates of the contexts symbol probabilities to adapt the symbol probabilities associated with each context to the actual image content. By means of this measure, the symbol probabilities are adapted to the actual symbol probabilities statistics.

Another case where neighborhood attributes affect the reconstruction of the current portion of the image 10, such as the current encoding unit 30, is predictive decoding in the predictor 28. The prediction is not only limited to the content of the prediction in the current encoding unit 30, but may also cover the prediction of the parameters contained in the data stream 12 for the current coding block 30, such as prediction parameters, split data, or even transform coefficients. Those. predictor 28 may predict image content or such parameters from the aforementioned neighborhood to obtain a recorded signal, which is then combined with the prediction residual obtained by module 26 from data stream 12. In the case of prediction parameters, predictor 28 may use the syntax elements contained in the data stream as prediction residuals to obtain the actual value of the prediction parameter. Predictor 28 uses the last prediction parameter value to obtain the just-mentioned prediction signal to be combined with the prediction residual in combiner 27.

The above "neighborhood" mainly covers the upper left part of the circumference of the current section to which the syntax element currently to be entropy decoded or the syntax element to be currently predicted belongs. In FIG. 25, such a neighborhood is shown at 34 as an example for one coding block 30 .

The encoding/decoding order is determined among the encoding blocks 30: at the most rough level, the encoding tree blocks 32 of the image 10 are scanned in scan order 36, in this case depicted as a raster scan occurring line by line from top to bottom. Within each coding tree block, the coding blocks 30 are scanned in depth-first order, so that, at each hierarchical level, the coding tree block 32 is scanned essentially also by a top-to-bottom raster scan.

The scan order defined among the coding units 30 is consistent with the definition of the neighborhood 34 used to derive an attribute in the neighborhood to select contexts and/or perform spatial prediction, in that the neighborhood 34 mainly covers areas of the image 10 that have already been subjected to decoding according to the coding order. Whenever neighborhood area 34 covers inaccessible areas of image 10, default data is used instead. For example, neighborhood pattern 34 may extend beyond image 10. Another possibility, however, is that neighborhood 34 extends into an adjacent slice.

The slices divide, for example, the picture 10 according to the encoding/decoding order determined by the encoding units 30, i.e. each slice is a continuous, uninterrupted sequence of coding blocks 30 in accordance with the aforementioned order of coding blocks. In FIG. 25, the slices are indicated by dotted lines 14. The order determined among the slices 14 is the result of their arrangement of executions of consecutive coding blocks 30, as summarized above. If syntax element section 18 of a slice 14 indicates that it should be decoded in the first mode, then entropy decoder 24 enables context adaptive entropy decoding to derive contexts across slice boundaries. Those. spatial neighborhood 34 is used to select contexts when entropy decoding data relating to the current slice 14. In the case of FIG. entropy decoder 24 may use attributes derived from decoding the segments in an adjacent slice, such as slice number 1. Predictor 28 behaves the same way: for slices in the first mode 20, predictor 28 uses spatial prediction across a slice boundary spanning the current slice.

For slices, however, having a second mode 22 associated with them, ie. for which syntax element section 18 indicates second mode 22, entropy decoder 24 and predictor 28 restrict entropy context derivation and predictive decoding to depend on attributes pertaining to sections lying only within the current slice. Obviously, encoding efficiency suffers from this limitation. On the other hand, slices of the second mode 22 take into account the breaking of interdependencies between the sequence of slices. Therefore, slices of the second mode 22 may be distributed within the image 10, or within the video to which the image 10 belongs, in order to take resynchronization points into account. It is not necessary, however, that each image 10 has at least one slice in the second mode 22.

As already mentioned above, the first and second modes 20 and 22 also differ in their initialization of the symbol probabilities. Slices encoded in the second mode 22 cause entropy decoder 24 to reinitialize the probabilities independently of any previously decoded slice, i. previously decoded in the sense of the order defined among the slices. The symbol probabilities are, for example, set to default values known to both the encoding and decoding side, or the initialization values are contained in slices encoded in the second mode 22.

Those. for slices encoded/decoded in the second mode 22, adaptation of the symbol probabilities always starts immediately with the start of those slices. Therefore, the adaptation accuracy is poor for these slices at the beginning of these slices.

This is not the case for slices encoded/decoded in the first mode 20. For the latter slices, the initialization of the symbol probabilities performed by the entropy decoder 24 depends on the stored symbol probability states of the previously decoded slice. Whenever a slice being encoded/decoded in the first mode 20 has its origin, for example, located other than the left side of the image 10, i.e. not on the side from where the raster scan 36 starts execution line by line before stepping down the next line, the symbol probabilities resulting at the end of the entropy decoding of the immediately preceding slice are received. This is shown, for example, in FIG. 2 by arrow 38 for slice #4. Slice #4 has its origin somewhere between the right side and the left side of the image 10, and therefore, when initializing the symbol probabilities, the entropy decoder 24 receives, when initializing the symbol probabilities, the symbol probabilities that were obtained from the entropy decoding of the immediately preceding slice, t .e. slice No. 3, until it ends, i.e. including continuous updating of symbol probabilities during slice #3 entropy decoding until it ends.

Slices having a second mode 22 associated with them, which, however, originate on the left side of the image 10, such as slice #5, for example, do not accept the symbol probabilities obtained after the end of the entropy decoding of the immediately preceding slice #4, since this would prevent the decoder 5 from decoding the image 10 in parallel by using waveform processing. Rather, as summarized above, entropy decoder 24 adapts the symbol probabilities obtained after the end of entropy decoding of the second - in coding/decoding order 36 - coding tree block 32 in the immediately preceding - in coding/decoding order 36 - coding tree block, as indicated by the arrow. 40.

In Fig. 25, for example, the image 10 has been divided into three rows of coding tree blocks and four columns of coding tree root blocks 32 as an example, and each row of coding tree blocks has been subdivided into two slices 14, so that the beginning of every second slice matches the first coding unit in the order of coding units of the corresponding row of blocks at the root of the coding tree. The entropy decoder 24 is therefore able to use wave processing in decoding the image 10 by decoding in parallel each coding tree root block row, decoding of these coding tree root block rows starting in a stepwise fashion starting from the first or topmost coding tree root block row, then a second, and then a third.

Of course, splitting the blocks 32 recursively into additional coding blocks 30 is optional, and therefore, more generally, blocks 32 may also be referred to as "coding blocks". Those. generally speaking, image 10 may be partitioned into coding blocks 32 arranged in rows and columns and having a raster scan order 36 defined between them, and decoder 5 may be considered to associate each slice 14 with a contiguous subset of coding blocks 32 in raster scan order 36, so that the subsets follow each other according to the raster scan order 36 according to the slice order.

As also clear from the above description, decoder 5, or more specifically entropy decoder 24, may be configured to store symbol probabilities obtained from context-adapted entropy decoding of any slice up to the second coding block in the coding block string according to scan order 36 raster. When initializing symbol probabilities for context-adaptive entropy decoding of a current slice having a first mode 20 associated therewith, decoder 5, or more specifically entropy decoder 24, checks whether the first coding block 32 of a contiguous subset of coding blocks 32 associated with the current slice, the first coding block 32 in the coding block row according to the raster scan order 36 . If so, the symbol probabilities for context-adaptive entropy decoding of the current slice are initialized as explained in relation to arrow 40, namely, depending on the stored symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block in the coding block row according to with an order of 36 raster scans. If not, initialization of symbol probabilities for context adaptive entropy decoding of the current slice is performed depending on the symbol probabilities obtained by context adaptive entropy decoding of the previously decoded slice to the end of the previously decoded slice, i.e. according to arrow 38. Again, in the case of initialization according to position 38, the saved state at the end of the entropy decoding of the immediately preceding slice in the order of 36 slices is meant, while in the case of initialization 40 it is this previously decoded slice containing the end of the second block of the immediately preceding row block 32 in the order of 36 blocks.

As shown by dashed lines in FIG. 24, a decoder may be configured to respond to syntax element portion 18 in the current slice of slices 14 to decode the current slice in accordance with one of at least three modes. Those. there may be a third mode 42 besides the other modes 20 and 22. The third mode 42 may differ from the second mode 22 in that prediction across slice boundaries is allowed while entropy encoding/decoding is still limited to not cross slice boundaries.

Two embodiments have been presented above with regard to syntax element section 18. The table below summarizes these two embodiments.

In one embodiment, syntax element section 18 is formed individually by dependent_slice_flag, while in another embodiment, the combination of dependent_slice_flag and no_cabac_reset_flag forms a syntax element section. Reference is made to the synchronization process for context variables with respect to initializing symbol probabilities depending on the stored symbol probability states of a previously decoded slice. In particular, the decoder may be configured to, if last_ctb_cabac_init_flag=0 and tiles_or_entropy_coding_sync_idc=2, store the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block in the row according to the raster scan order, and, upon initialization symbol probabilities for context-adaptive entropy decoding of the current slice according to the first mode, checking if the first coding block of a contiguous subset of coding blocks associated with the current slice is the first coding block in a row according to the raster scan order, and if so , initialization of the symbol probabilities for context-adaptive entropy decoding of the current slice depending on the stored symbol probabilities obtained in the context-adaptive entropy decoding of the previously decoded slice to the second coding block in the line, respectively raster scan order, and if not, initializing symbol probabilities for context adaptive entropy decoding of the current slice depending on the symbol probabilities obtained by context adaptive entropy decoding of the previously decoded slice to the end of the previously decoded slice.

Thus, in other words, according to the second embodiment for the syntax, the decoder recovers the image 10 from the data stream 12 in which the image is encoded in units of slices 14 into which the image (10) is divided, and the decoder is configured to decode the slices 14 from data stream 12 in accordance with the order of 16 slices, and the decoder responds to the section 18 of the syntax element, namely the dependent_slice_flag in the current slice of slices, to decode the current slice in accordance with one of at least two modes 20, 22. In accordance with the first 20 of the at least two modes mentioned, namely, if dependent_slice_flag=1, the decoder decodes the current slice from data stream 12 using context-adaptive entropy decoding 24, including deriving contexts across slice boundaries, continuously updating contexts symbol probabilities, and initializing 38, 40 symbol probabilities depending on saved s symbol probability states of the previously decoded slice, and prediction decoding across slice boundaries, and in accordance with the second of the at least two modes mentioned, namely, if dependent_slice_flag=0, the decoder decodes the current slice from the data stream 12 using context-adaptive context output constrained entropy decoding so as not to cross slice boundaries, continuously updating context symbol probabilities and initializing symbol probabilities independently of any previously decoded slice, and constrained predictive decoding decoding predictive decoding so as not to cross slice boundaries. Image 10 may be partitioned into coding blocks 32 arranged in rows and columns and having a raster scan order 36 defined between them, and the decoder is configured to associate each slice 14 with a contiguous subset of coding blocks 32 in raster scan order 36 such that the subsets follow each other in accordance with the raster scan order 36 in accordance with the order of the slices. The decoder may be configured to, namely, responsive to tiles_or_entropy_coding_sync_idc=2, store the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block 32 in the line according to the raster scan order 36, and, when initializing the symbol probabilities for context-adaptive entropy decoding of the current slice according to the first mode, checking if the first coding block of the contiguous subset of coding blocks 32 associated with the current slice is the first coding block 32 in a row according to the raster scan order, and if so , initializing 40 symbol probabilities for context-adaptive entropy decoding of the current slice depending on the stored symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block in the row according to raster scan rate 36, and if not, initializing 38 symbol probabilities for context-adaptive entropy decoding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the end of the previously decoded slice. The decoder may be configured to respond to the plot (18) of the syntax element in the current slice of slices 14 to decode the current slice in accordance with one of at least three modes, namely, in one of the first 20 and third mode 42 or the second mode 22, and the decoder is configured, in accordance with the third mode 42, namely, if dependent_slice_flag =1 and tiles_or_entropy_coding_sync_idc=3, decoding the current slice from the data stream using context-adaptive entropy decoding with context derivation constraint, so as not to cross boundaries slices, continuously updating symbol probabilities of contexts, and initializing symbol probabilities independently of any previously decoded slice, and predictive decoding across slice boundaries, with one of the first and third modes being selected depending on the syntax element, namely cabac_independent_flag. The decoder may further be configured to, namely, if tiles_or_entropy_coding_sync_idc=0.1 and 3 ("3" when cabac_independent_flag=0), store the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the end of the previously decoded slice, and, when initializing symbol probabilities for context adaptive entropy decoding of the current slice according to the first mode, initializing symbol probabilities for context adaptive entropy decoding of the current slice depending on the stored symbol probabilities. The decoder may be configured to, namely, if tiles_or_entropy_coding_sync_idc=1, in the first and second mode, limit predictive decoding in tiles into which the image is subdivided.

Of course, the encoder is able to set the above syntax appropriately to enable the decoder to obtain the above benefits. The encoder may be an encoder, such as multi-core, parallel processing, but this is not necessary. To encode image 10 into data stream 12 in units of slices 14, the encoder is configured to encode slices 14 into data stream 12 in accordance with the 16 slice order. The encoder determines the syntax element section 18 for the current slice of slices, and encodes it into it, so that the syntax element section signals that the current slice should be encoded in accordance with one of the at least two mentioned modes 20, 22, and if the current slice to be encoded in accordance with the first 20 of the at least two mentioned modes, encodes the current slice into data stream 12 using context-adaptive entropy coding 24, including inference of contexts across slice boundaries, continuous updating of contexts symbol probabilities, and initialization 38 , 40 symbol probabilities depending on the stored symbol probability states of the previously encoded slice, and cross-slice boundary predictive coding, and if the current slice is to be encoded according to the second 22 of the at least two modes, encodes the current slice into stream 12 data using a context-adaptive entropy encoder context derivation constrained encoding so as not to cross slice boundaries, continuous updating of context symbol probabilities and initialization of symbol probabilities independently of any previously encoded slice, and constrained predictive coding predictive coding not to cross slice boundaries. Although the image 10 may be partitioned into coding blocks 32 arranged in rows and columns and having a raster scan order 36 defined between them, an encoder may be configured to associate each slice 14 with a contiguous subset of coding blocks 32 in a raster scan order 36 such that the subsets follow one after the other according to the raster scan order 36 according to the slice order. The encoder may be configured to store the symbol probabilities obtained by context-adaptive entropy encoding of the previously encoded slice up to the second coding unit 32 in a row according to the raster scan order 36, and, when initializing the symbol probabilities for context-adaptive entropy coding of the current slice in according to the first mode, checking whether the first coding block of the contiguous subset of coding blocks 32 associated with the current slice is the first coding block 32 in a row according to the raster scan order, and if so, initializing 40 symbol probabilities for context-adaptive entropy coding of the current slice depending on the stored symbol probabilities obtained by context-adaptive entropy coding of the previously encoded slice to the second coding block in the line according to the raster scan order 36 and, if not, the initialization 38 believing of the symbol specificities for context-adaptive entropy coding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy coding of the previously decoded slice to the end of the previously coded slice. The encoder may be configured to encode a portion (18) of the syntax element into the current slice of slices (14), so that the current slice is signaled to be encoded into it in accordance with one of at least three modes, namely one of the first (20) and the third mode (42) or the second mode (22), and the encoder is configured, ** in accordance with the third mode (42), to encode the current slice into the data stream using context-adaptive entropy coding with output restriction contexts so as not to cross slice boundaries, continuously updating the symbol probabilities of the contexts and initializing the symbol probabilities independently of any previously encoded slice, and predictive coding across slice boundaries, the encoder distinguishing between one of the first and third modes using, for example, a syntax element, and namely the cabac_independent_flag. The encoder may be configured to determine a generic syntax element such as dependent_slices_present_flag and write it to the data stream, operating in one of at least two generic modes of operation depending on the generic syntax element, namely, with, according to the first generic mode of operation, performing encoding of a portion of the syntax element for each slice, and, according to the second generalized mode of operation, inevitably using another one of the at least two modes, in addition to the first mode. The encoder may be configured, according to the first and second modes, to inevitably and continuously continue to continuously update the symbol probabilities from the beginning to the end of the current slice. The encoder may be configured to store the symbol probabilities obtained by context-adaptive entropy encoding of the previously encoded slice to the end of the previously encoded slice, and, when initializing the symbol probabilities for context-adaptive entropy encoding of the current slice in accordance with the first mode, initializing the symbol probabilities for context-adaptive entropy coding of the current slice depending on the stored symbol probabilities. And, the encoder may, in the first and second mode, limit the predictive coding to the tiles into which the image is subdivided.

A possible encoder design is shown in FIG. 26 for completeness. Predictor 70 works almost the same as predictor 28, i.e. performs prediction, but also determines by optimization, for example, coding parameters including prediction parameters and modes. Modules 26 and 27 are also in the decoder. The subtractor 72 determines a lossless prediction residual which is then - through the use of quantization and optionally the use of a spectral decomposition transform - lossy encoded in the transform and quantization module 74 . Entropy encoder 76 performs context adaptive entropy coding.

In addition to the above specific syntax examples, another example is briefly described below to represent the consistency between the terms used herein below and the terms used above.

In particular, without specific brief description above, dependent slices are not only "dependent" in that they allow for the application of knowledge known outside their boundaries, such as those mentioned above, whose entropy contexts adapt faster, or achieve better spatial prediction. because of the permission to cross their borders. Rather, in order to save the overhead required to define slice headers by slicing an image, dependent slices adopt part of the slice header syntax from previous slices, i.e. this portion of the slice syntax header is not passed again for dependent slices. This is shown, for example, in FIG. 16 at 100 and in FIG. 21 at 102, whereby the slice type is, for example, taken from the previous slice. By this measure, subdivision of an image into slices such as an independent slice and dependent slices is less costly in terms of bit consumption.

It is the aforementioned dependency that leads, in the example briefly described below, to a slightly different formulation: slices are defined as unit areas of an image in which the slice header syntax is individually settable. Therefore, slices consist of one - using the notation above - independent/regular/normal slice, now called independent slice segment, and without one or more - using the notation above - dependent slices, now called dependent slice segments.

27, for example, shows an image to be split into two slices, one formed by slice segments 14 ₁ to 14 ₃ and the other formed exclusively by slice segment 14 ₄ . Indexes 1-4 show the order of slices in encoding order. Figs. 28a and b show another example in the case of dividing the image 10 into two tiles, where in the case of Fig. 28a one slice is formed by all five slice segments 14 covering both tiles 50 ₁ and 50 ₂ - the index increases again in the coding order - and, in the case of Fig. 28a, two slices are formed by slice segments 14 ₁ and 14 ₂ and 14 ₃ and 14 ₄ respectively, subdividing tile 50 ₁ , and the other slice is formed by slice segments 14 ₅ -14 ₆ spanning tile 50 ₂ .

The definitions can be:

dependent slice segment : A slice segment for which the values of some syntax elements of the slice segment header are implied from the values for the previous independent slice segment in decoding order - earlier, in the above embodiments - called dependent slice .

independent slice segment : A slice segment for which the values of the slice segment header syntax elements are not inferred from the values for the previous slice segment - formerly, in the above embodiments , called a normal slice .

slice : The integer number of coding tree units contained in one independent slice segment and all subsequent dependent slice segments (if any) that precede the next independent slice segment (if any) in the same access unit/picture .

slice header : The slice segment header of an independent slice segment that represents the current slice segment or an independent slice segment that precedes the current dependent slice segment .

slice segment : An integer number of coding tree units ordered sequentially in a tile scan and contained in a single NAL unit ; dividing each image into slice segments is a partition .

slice segment header : Part of the encoded slice segment containing data elements related to the first or all encoding tree units represented in the slice segment.

Signaling "modes" 20 and 22, i.e. "dependent slice segment" and "independent slice segment" could be as follows:

In some additional NAL units, such as a Picture Parameter Set (PPS), a syntax element can be used to signal whether or not dependent slices are used for some picture, even sequence for some pictures:

dependent_slice_segments_enabled_flag equal to 1 specifies the presence of the dependent_slice_segment_flag syntax element in slice segment headers. dependent_slice_segments_enabled_flag equal to 0 specifies that the dependent_slice_segment_flag syntax element is not present in slice segment headers.

The dependent_slice_segments_enabled_flag is similar in scope to the previously described dependent_slices_present_flag.

Likewise, dependent_slice_flag may be called dependent_slice_segment_flag to take into account different notation for slices.

dependent_slice_segment_flag equal to 1 specifies that the value of each slice segment header syntax element that is not present in the current slice segment header is assumed to be equal to the value of the corresponding slice segment header syntax element in the slice header, i.e. the slice segment header of the preceding independent slice segment.

At the same level, such as the image level, the following syntax element may be included:

entropy_coding_sync_enabled_flag equal to 1 specifies that a specific synchronization process for context variables is called before decoding a coding tree unit that includes the first coding tree block of a string of coding tree blocks in each tile in each picture referencing a PPS, and a specific save process for context variables is called after decoding a coding tree unit that includes a second coding tree block of a string of coding tree blocks in each tile in each picture referring to the PPS. entropy_coding_sync_enabled_flag equal to 0 specifies that a particular synchronization process is not required to be invoked on context variables before decoding a coding tree unit that includes the first coding tree block of a line of coding tree blocks in each tile in each picture referencing a PPS, and a particular process is not required to be invoked saving for context variables after decoding a coding tree unit that includes a second coding tree block of a string of coding tree blocks in each tile in each picture referring to the PPS.

The bitstream conformance requirement is that the value of entropy_coding_sync_enabled_flag must be the same for all PPSs that are enabled in CVS.

When entropy_coding_sync_enabled_flag is 1 and the first coding tree block in a slice is not the first coding tree block of a coding tree block row in a tile, the bitstream matching requirement is that the last coding tree block in the slice must belong to the same coding tree block row as the first block of the coding tree in the slice. When entropy_coding_sync_enabled_flag is 1 and the first coding tree block in a slice segment is not the first coding tree block of a coding tree block row in a tile, the bitstream matching requirement is that the last coding tree block in the slice segment must belong to the same coding tree block row, as the first block of the coding tree in the slice segment.

As already described, the order of encoding/decoding among the CTBs 30 results in a top-down progressive raster form, starting with the first tile scan, then moving on to the next tile if there is more than one tile in the image.

The decoder 5 - and the encoder, respectively - operates as follows when entropy decoding (coding) segments 14 of the image slice:

A1) Whenever the currently decoded/encoded synEl syntax element is the first syntax element of tile 50, slice segment 14 or CTB row, the initialization process of FIG. 29 starts.

A2) Otherwise, this syntax element is decoded using the current entropy contexts.

A3) If the current syntax element was the last syntax element in CTB 30, then the entropy context saving process starts as shown in FIG.

A4) The process continues to A1) with the next syntax element.

The initialization process checks 200 whether synEl is the first syntax element of slice segment 14 or tile 50. If so, contexts are initialized regardless of any previous slice segment at step 202. If not, it is checked 204 whether synEl is the first syntax element of row CTB 30, and whether entropy_coding_sync_enabled_flag is equal to one. If so, it is checked 206 if a second CTB 30 is available in the previous row of the same tile CTB 30 (see FIG. 23). If yes, at step 210, the context acceptance is performed according to position 40, using the currently stored context probabilities to accept type 40. If not, the contexts are initialized regardless of any previous slice segment at step 202. step 212 checks if synEl is the first syntax element in the first CTB of dependent slice segment 14 and is equal to one dependent_slice_segment_flag, and if so, step 214 performs a context acceptance according to position 38 using the currently stored context probabilities for acceptances type 38. After any of steps 214, 212, 210, and 202, decoding/encoding actually begins.

Dependent slice segments with dependent_slice_segment_flag equal to one thus help to further reduce the encoding/decoding delay with almost no deterioration in encoding efficiency.

In the storage process of FIG. 30, it is checked in step 300 whether the encoded/decoded synEl is the last syntax element of the second CTB 30 of the CTB 30 and is equal to one entropy_coding_sync_enabled_flag . If so, the current entropy contexts are saved at 302, i. e. entropy encoding probabilities of contexts, in a memory that is special for type acceptances 40. Similarly, in step 304 it is checked, in addition to steps 300 or 302, whether encoded/decoded synEl is the last syntax element of slice segment 14, and whether the dependent_slice_segment_flag is equal to one . If so, the current entropy contexts are stored at 306, i. e. entropy encoding probabilities of contexts, in a storage device that is special for type 38 acceptances.

It is noted that any check that asks if a syntax element is the first synEl of a CTB string uses, for example, the slice_address 400 syntax element in the slice segment headers, i. e. a start syntax element indicating the start positions of the corresponding slice segment according to the decoding order.

When reconstructing picture 10 from data stream 12 using WPP processing, the decoder is able to apply exactly the last start parse 400 to show entry points of WPP substreams. Since each slice segment contains a start syntax section 400 indicating the decoding start position of the corresponding slice segment in the picture 10, the decoder is able to identify entry points of WPP substreams in which slice segments are grouped by identifying, using the start syntax sections 400 of slice segments, slice segments, starting on the left side of the image. The decoder can then decode the WPP substreams in parallel in a staggered manner, with sequential start of decoding the WPP substreams according to the slice order. Slice segments can even be smaller than the width of one image, i.e. one CTB line so that their transmission can be interleaved among the WPP sub-streams to further reduce the overall end-to-end transmission delay. The encoder provides each slice (14) with a start syntax section (400) indicating the encoding start position of the corresponding slice in the image (10) and groups the slices into WPP substreams such that for each WPP substream, the first slice in the slice order starts on the left side of the image. The encoder can even, of course, use WPP processing when encoding the picture: the encoder encodes the WPP substreams in a staggered manner in parallel, sequentially starting encoding the WPP substreams according to the slice order.

Incidentally, the last aspect of using the slice segment start syntax regions as a means to locate WPP subflow entry points can be used without the principle of dependent slices.

It is valid for all for parallel image processing 10 to set the above variables as follows:

It is even legal to mix WPP with tile splitting. In this case, you can consider the tiles as individual images; each that WPP uses consists of a slice having one or more dependent slice segments, and the checks at step 300 and 208 refer to the second CTB in the aforementioned CTB row in the same tile, just as steps 204 and A1 refer to the first CTB 30 in line CTB 30 of the current tile! In this case, the above table can be expanded:

As a quick note, the last extension is also possible with option 2. Embodiment 2 enables the following processing:

But with the following extensions, the table below results in:

Add to image parameter set semantics:

If tiles_or_entropy_coding_sync_idc is 4, each but the first CTB row must be contained in another slice with the dependent slice flag set to 1. CTBs of other rows must not be present in the same slice. There may be more than one slice present per CTB row.

If tiles_or_entropy_coding_sync_idc is 5, the CTB of every but the first tile must be contained in another slice. CTBs of other tiles must not be present in the same slice. There may be more than one slice present per tile.

See Fig.31 for further explanation.

Those. the above table can be extended:

With regard to the above embodiments, it should be noted that the decoder may be configured to, for example, respond to tiles_or_entropy_coding_sync_idc=1,2, in the first and second mode, read information from the current slice, indicating the subdivision of the current slice into parallel subsections, wherein the parallel subsections can be WPP substreams or tiles, terminating context-adaptive entropy decoding at the end of the first parallel subsection and resuming context-adaptive entropy decoding at the start of any subsequent parallel subsection, including, in the first mode, initialization of symbol probabilities depending on the stored probability states symbol of the preceding parallel subsection, and, in a second mode, initializing the symbol probabilities independently of any previously decoded slice and any previously decoded parallel subsection.

Thus, the above description shows methods for encoding, decoding, encapsulating, and transmitting with low latency structured video data provided by the new HEVC coding standard, such as structured in tiles, wave parallel processing (WPP) substreams, slices, or entropy slices.

Specifically, it has been determined how to transport parallel encoded data in a conversational scenario in order to obtain minimum latency in the process of encoding, decoding and transmission. Therefore, a pipelined parallel encoding, transmission, and decoding approach has been described to enable low-latency applications like games, telesurgery, and so on.

In addition, the above embodiments have closed the gap of wave parallel processing (WPP), making it suitable for use in low latency transmission scenarios. Therefore, a new encapsulation format for WPP substreams 0, dependent slice, has been introduced. This dependent slice may contain entropy slice data, a WPP substream, a full LCU string, a slice fragment only, where the previously passed slice header is also applied to the contained fragment data. The contained data is signaled in the auxiliary slice header.

Finally, it is noted that the naming for new slices could also be "subset/lightweight slices", but the name "dependent slice" was found to be the best.

Signaling has been introduced that describes the level of parallelism in encoding and transport.

Although some aspects have been described in the context of a device, it is clear that these aspects also represent a description of the corresponding method, where the block or device corresponds to a method step or a feature of a method step. Likewise, the aspects described in the context of a method step also provide a description of the corresponding block or element or feature of the corresponding device. Some or all of the steps of the method may be performed by (or use) a hardware device such as, for example, a microprocessor, a programmable computer, or an electronic circuit. In some embodiments, some one or more of the most important steps of the method may be performed by such a device.

Depending on certain implementation requirements, embodiments of the invention may be implemented in hardware or software. The implementation may be carried out using a media for storing digital data, such as floppy disk, digital versatile disc (DVD), Blu-ray disc, compact disc (CD), read only memory (ROM), programmable ROM (PROM), erasable programmable ROM ( EPROM), electrically erasable programmable ROM (EEPROM), or flash memory having electronically readable control signals stored thereon that interact (or methods of interact) with a programmable computer system such that the corresponding method is performed. Therefore, the digital data storage medium may be computer-readable.

Some embodiments of the invention comprise a storage medium having electronically readable control signals that are capable of interfacing with a programmable computer system such that one of the methods described herein is performed.

Typically, embodiments of the present invention may be implemented as a computer program product with program code, the program code being operable to perform one of the methods when the computer program product is executing on a computer. The program code may, for example, be stored on a machine readable medium.

Other embodiments include a computer program for performing one of the methods described herein, stored on a machine readable medium.

In other words, an embodiment of an inventive method, therefore, is a computer program having program code for performing one of the methods described herein when the computer program is running on a computer.

Another embodiment of the inventive methods, therefore, is a storage medium (or digital data storage medium or computer-readable medium) containing a computer program recorded thereon for performing one of the methods described herein. The storage medium, digital data storage medium or recorded medium is usually tangible and/or durable.

Another embodiment of an inventive method, therefore, is a data stream or sequence of signals representing a computer program for performing one of the methods described herein. The data stream or signal sequence, for example, may be configured to be transmitted over a data connection, such as the Internet.

Another embodiment comprises a processing means, such as a computer or programmable logic device, capable of or adapted to perform one of the methods described herein.

Another embodiment comprises a computer having a computer program installed thereon for performing one of the methods described herein.

Another embodiment according to the invention comprises an apparatus or system configured to send (eg, electronically or optically) a computer program for performing one of the methods described herein to a receiver. The receiver may, for example, be a computer, a mobile device, a memory device, or the like. The device or system, for example, may include a file server for sending a computer program to a receiver.

In some embodiments, a programmable logic device (eg, a field programmable gate array) may be used to perform some or all of the functionality of the methods described herein. In some embodiments, a programmable gate array may communicate with a microprocessor to perform one of the methods described herein. Typically, the methods are preferably performed by any hardware device.

The above described embodiments are merely illustrative of the principles of the present invention. It is clear that modifications and variations of the devices and details described in this document are obvious to those skilled in the art. Therefore, the intent is that it is only limited by the scope of the pending claims and not by the specific details provided by way of describing and explaining the embodiments herein.

Another embodiment comprises a decoder for restoring an image (10) from a data stream (12) into which the image is encoded in units of slices (14) into which the image (10) is divided, the decoder being configured to decode slices (14) from a stream ( 12) data according to slice order (16), and the decoder responds to the syntax element portion (18) in the current slice of slices to decode the current slice according to one of at least two modes (20, 22), and,

in accordance with the first (20) of the at least two mentioned modes, decoding the current slice from the data stream (12) using context-adaptive entropy decoding (24), including deriving contexts across slice boundaries, continuously updating context symbol probabilities, and initializing (38, 40) the symbol probabilities depending on the stored symbol probability states of the previously decoded slice, and cross-slice boundary predictive decoding, and,

in accordance with the second (22) of said at least two modes, decoding the current slice from the data stream (12) using context-adaptive entropy decoding with context derivation constrained to avoid slice boundaries, continuously updating context symbol probabilities, and initializing probabilities symbol regardless of any previously decoded slice, and predictive decoding with predictive decoding constraint not to cross slice boundaries.

In an additional embodiment, a decoder is provided in which the image (10) is divided into coding blocks (32) arranged in rows and columns and having a raster scan order (36) defined between them, and the decoder is configured to associate each slice (14) with a continuous subset of coding blocks (32) in raster scan order (36), so that the subsets follow each other in accordance with the raster scan order (36) in accordance with the slice order.

In a further embodiment, a decoder is provided, wherein the decoder is configured to store the symbol probabilities obtained by context-adaptive entropy decoding of a previously decoded slice to a second coding block (32) in a row according to a raster scan order (36) and, upon initializing the probabilities symbol for context-adaptive entropy decoding of the current slice in accordance with the first mode, checking whether the first coding block of a continuous subset of coding blocks (32) associated with the current slice is the first coding block (32) in a row in accordance with the raster scan order, and, if so, initializing (40) the symbol probabilities for context-adaptive entropy decoding of the current slice depending on the stored symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block in the row, respectively and with raster scan order (36), and if not, initialization (38) of symbol probabilities for context-adaptive entropy decoding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the end of the previously decoded slice.

In a further embodiment, a decoder is provided, wherein the decoder is configured to respond to a syntax element portion (18) in a current slice of slices (14) to decode the current slice in accordance with one of at least three modes, namely one of first (20) and third mode (42) or second mode (22), and the decoder is configured to

according to the third mode (42), decoding the current slice from the data stream using context-adaptive entropy decoding with context output constrained to avoid slice boundaries, continuously updating the symbol probabilities of the contexts, and initializing the symbol probabilities independently of any previously decoded slice, and predictive decoding across slice boundaries,

wherein one of the first and third modes is selected depending on the syntax element.

In a further embodiment, a decoder is provided, wherein the decoder is configured to respond to a generic syntax element in the data stream to operate in one of at least two generic modes of operation, with, according to the first generic mode of operation, performing response to a portion of the syntax element for each slice. , and, according to the second generalized mode of operation, the inevitable use of another one of the at least two mentioned modes other than the first mode.

In a further embodiment, a decoder is provided, wherein the decoder is configured, according to the first and second modes, to inevitably and continuously continue to continuously update symbol probabilities from the beginning to the end of the current slice.

In a further embodiment, a decoder is provided, wherein the decoder is configured to store symbol probabilities obtained by context-adaptive entropy decoding of a previously decoded slice to the end of the previously decoded slice, and, when initializing the symbol probabilities for context-adaptive entropy decoding of the current slice in accordance with the first mode, initializing symbol probabilities for context-adaptive entropy decoding of the current slice depending on the stored symbol probabilities.

In a further embodiment, a decoder is provided, wherein the decoder is configured, in the first and second modes, to limit predictive decoding to the tiles into which the image is subdivided.

In a further embodiment, a decoder is provided, wherein the decoder is configured, in first and second modes, to read information from the current slice showing subdivision of the current slice into parallel subsections, to terminate context-adaptive entropy decoding at the end of the first parallel sub-section, and to resume context-adaptive entropy decoding. decoding again at the beginning of any subsequent parallel subsection, including, in a first mode, initialization of symbol probabilities depending on the stored symbol probability states of the previous parallel subsection and, in a second mode, initialization of symbol probabilities independently of any previously decoded slice and any previously decoded parallel subsection.

In a further embodiment, a decoder is provided, wherein the decoder is configured, in accordance with the first (20) of said at least two modes, to copy, for the current slice, a portion of the slice header syntax from a previous slice decoded in the second mode.

In a further embodiment, a decoder is provided, wherein the decoder is configured to reconstruct an image (10) from a data stream (12) using WPP processing, with each slice (14) comprising a start syntax section (400) indicating the decoding start position of the corresponding slice in the image (10), and in which the decoder is configured to

identifying the entry points of the WPP substreams into which slices are grouped by identifying, using slice start syntax portions, slices starting on the left side of the image, and

decoding the WPP substreams in parallel in a staggered manner, with sequential start of decoding the WPP substreams according to the slice order.

In another embodiment, an encoder is provided for encoding an image (10) into a data stream (12) in units of slices (14) into which the image (10) is divided, the encoder being configured to encode the slices (14) into a data stream (12) into according to the order (16) of slices, and the encoder is configured to

determining a syntax element section (18) for the current slice of slices, and encoding it into it, such that the syntax element section signals that the current slice should be encoded in accordance with one of at least two modes (20, 22), and,

if the current slice is to be encoded in accordance with the first (20) of the at least two mentioned modes, encoding the current slice into the data stream (12) using context-adaptive entropy coding (24), including deriving contexts across slice boundaries, continuously updating the symbol probabilities of the contexts and initializing (38, 40) the symbol probabilities depending on the stored symbol probabilities states of the previously encoded slice, and cross-slice boundary predictive coding, and,

if the current slice is to be encoded in accordance with the second (22) of said at least two modes, encoding the current slice into the data stream (12) using context-adaptive entropy coding with context derivation constraint so as not to cross slice boundaries, continuous update contexts symbol probabilities and initializing the symbol probabilities independently of any previously encoded slice, and constrained predictive coding to not cross slice boundaries.

In an additional embodiment, an encoder is provided, wherein the image (10) is divided into coding blocks (32) arranged in rows and columns and having a raster scan order (36) defined between them, and the encoder is configured to associate each slice (14) with a continuous subset of coding blocks (32) in raster scan order (36), so that the subsets follow one after the other in accordance with the raster scan order (36) in accordance with the slice order.

In a further embodiment, an encoder is provided, wherein the encoder is configured to store the symbol probabilities obtained by context-adaptive entropy encoding of a previously encoded slice to a second coding block (32) in a row according to a raster scan order (36) and, upon initializing the probabilities character for context-adaptive entropy coding of the current slice in accordance with the first mode, checking whether the first coding block of a continuous subset of coding blocks (32) associated with the current slice is the first coding block (32) in a row in accordance with the raster scan order, and, if so, initializing (40) the symbol probabilities for context-adaptive entropy coding of the current slice depending on the stored symbol probabilities obtained by context-adaptive entropy coding of the previously encoded slice up to the second coding block in the row according to the order (36 ) scanning the raster, and if not, initializing (38) the symbol probabilities for context-adaptive entropy coding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy coding of the previously decoded slice to the end of the previously coded slice.

In a further embodiment, an encoder is provided, wherein the encoder is configured to encode a portion (18) of a syntax element into a current slice of slices (14), such that the current slice is signaled to be encoded into it in accordance with one of at least three modes. , namely in one of the first (20) and third mode (42) or second mode (22), and the encoder is configured to,

in accordance with the third mode (42), encoding the current slice into the data stream using context-adaptive entropy coding with constraint output of contexts so as not to cross slice boundaries, continuously updating the symbol probabilities of the contexts, and initializing the symbol probabilities independently of any previously encoded slice, and predictive coding across slice boundaries,

wherein the encoder distinguishes between one of the first and third modes using a syntax element.

In a further embodiment, an encoder is provided, wherein the encoder is configured to determine a generic syntax element and write it to the data stream, operating in one of at least two generic modes of operation depending on the generic syntax element, namely c, according to the first generic mode of operation, performing encoding of a portion of the syntax element for each slice, and, according to the second generalized mode of operation, inevitably using another one of the at least two modes, in addition to the first mode.

In a further embodiment, an encoder is provided, wherein the encoder is configured, according to the first and second modes, to inevitably and continuously continue continuously updating symbol probabilities from the beginning to the end of the current slice.

In a further embodiment, an encoder is provided, wherein the encoder is configured to store symbol probabilities obtained by context-adaptive entropy coding of a previously encoded slice to the end of the previously encoded slice, and, when initializing the symbol probabilities for context-adaptive entropy coding of the current slice according to the first mode, initializing symbol probabilities for context-adaptive entropy coding of the current slice depending on the stored symbol probabilities.

In a further embodiment, an encoder is provided, the encoder being configured, in the first and second modes, to limit predictive coding in tiles into which the image is subdivided.

In another embodiment, a decoder is provided for recovering an image (10) from a data stream (12) into which the image is encoded in units of slices (14) into which the image (10) is divided using WPP processing, the decoder being configured to decode the slices ( 14) from the data stream (12) in accordance with the order (16) of slices, each slice (14) contains a start syntax section (400) indicating the decoding start position of the corresponding slice in the image (10), and the decoder is configured to

identifying entry points of WPP substreams into which slices are grouped by identifying, using the slice start syntax sections (400), slices starting on the left side of the image,

decoding the WPP substreams in parallel in a staggered manner, with sequential start of decoding the WPP substreams according to the slice order.

In another embodiment, an encoder is provided for encoding an image (10) into a data stream (12) into which the image is encoded in units of slices (14) into which the image (10) is divided using WPP processing, the encoder being configured to encode slices ( 14) into the data stream (12) in accordance with the order (16) of slices, wherein the encoder is configured to provide each slice (14) with a start syntax section (400) indicating the start position of the encoding of the corresponding slice in the image (10), and the encoder made with the possibility

grouping slices into WPP substreams such that for each WPP substream, the first slice in slice order starts on the left side of the image, and

parallel encoding of the WPP substreams in a staggered manner, with sequential start of encoding of the WPP substreams according to the slice order.

In another embodiment, a method is provided for restoring an image (10) from a data stream (12), in which the image is encoded in units of slices (14) into which the image (10) is divided, the method comprising decoding slices (14) from the stream (12) data in accordance with the order (16) of slices, and the method responds to the plot (18) of the syntax element in the current slice of slices to decode the current slice in accordance with one of at least two modes (20, 22), in which,

in accordance with the first (20) of the at least two mentioned modes, the current slice is decoded from the data stream (12) using context-adaptive entropy decoding (24), including inference of contexts across slice boundaries, continuous updating of contexts symbol probabilities, and initializing (38, 40) the symbol probabilities depending on the stored symbol probability states of the previously decoded slice, and cross-slice boundary predictive decoding, and,

according to the second (22) of the at least two modes, the current slice is decoded from the data stream (12) using context-adaptive entropy decoding with context derivation constrained to avoid crossing slice boundaries, continuously updating context symbol probabilities, and initializing probabilities symbol regardless of any previously decoded slice, and predictive decoding with predictive decoding constraint not to cross slice boundaries.

In another embodiment, a method is provided for encoding an image (10) into a data stream (12) in units of slices (14) into which the image (10) is divided, the method comprising encoding slices (14) into a data stream (12) in accordance with the order (16) slices, and the method comprises

defining a syntax element section (18) for the current slice of slices and encoding it into it, such that the syntax element section signals that the current slice should be encoded according to one of at least two modes (20, 22), and,

if the current slice is to be encoded in accordance with the first (20) of the at least two mentioned modes, encoding the current slice into the data stream (12) using context-adaptive entropy coding (24), including deriving contexts across slice boundaries, continuously updating the symbol probabilities of the contexts and initializing (38, 40) the symbol probabilities depending on the stored symbol probabilities states of the previously encoded slice, and cross-slice boundary predictive coding, and,

if the current slice is to be encoded according to the second (22) of said at least two modes, encoding the current slice into the data stream (12) using context-adaptive entropy coding with context derivation constraint so as not to cross slice boundaries, continuous update contexts symbol probabilities and initializing the symbol probabilities independently of any previously encoded slice, and constrained predictive coding to not cross slice boundaries.

In another embodiment, a method is provided for recovering an image (10) from a data stream (12) in which the image is encoded in units of slices (14) into which the image (10) is divided using WPP processing, the method comprising decoding the slices (14) from of the data stream (12) in accordance with the order (16) of slices, each slice (14) contains a start syntax section (400) indicating the decoding start position of the corresponding slice in the image (10), and the method further comprises

identifying entry points of WPP substreams into which slices are grouped by identifying, using slice start syntax sections (400), slices starting on the left side of the image,

parallel decoding of WPP substreams in a staggered manner, with sequential start of decoding of WPP substreams according to slice order.

In another embodiment, a method is provided for encoding an image (10) into a data stream (12) into which the image is encoded in units of slices (14) into which the image (10) is divided using WPP processing, the method comprising encoding the slices (14) into a data stream (12) in accordance with the order (16) of slices, and providing each slice (14) with a start syntax section (400) indicating the start position of the encoding of the corresponding slice in the image (10), and additionally

grouping slices into WPP substreams such that for each WPP substream, the first slice in slice order starts on the left side of the image, and

parallel encoding of the WPP substreams in a staggered fashion, with sequential start of encoding of the WPP substreams according to slice order.

In another embodiment, a computer program is provided having program code for executing, when the program is executed on the computer, the method of claim 22 or 25.

Bibliography

Claims (27)

1. A method for restoring an image (10) from a data stream (12), in which the image is encoded in units of slices (14), into which the image (10) is divided, and the method comprises decoding slices (14) from the data stream (12) in accordance with with the order (16) of slices, and the method responds to the plot (18) of the syntax element in the current slice of said slices in order to decode the current slice in accordance with one of at least two modes (20, 22), while in accordance with the first (20) of the at least two mentioned modes, the current slice is decoded from the data stream (12) using context-adaptive entropy decoding (24), including inference of contexts across slice boundaries, continuous updating of contexts symbol probabilities, and initializing (38, 40) the symbol probabilities depending on the stored symbol probability states of the previously decoded slice, and predictive decoding across slice boundaries, and according to the second (22) of the at least two modes, the current slice is decoded from the data stream (12) using context-adaptive entropy decoding with context derivation constraint so as not to cross slice boundaries, continuously updating the context symbol probabilities, and initializing the probabilities symbol regardless of the previously decoded slice, and predictive decoding with predictive decoding constraint not to cross slice boundaries, moreover, the image (10) is divided into coding blocks (32) arranged in rows and columns and having a raster scan order (36) defined between them, and the method comprises associating each slice (14) with a continuous subset of coding blocks (32) in the order (36) raster scans such that the subsets follow each other according to the raster scan order (36) according to the slice order, and wherein the method comprises the steps of storing the symbol probabilities obtained by context-adaptive entropy decoding of the previously decoded slice to the second coding block (32) in a row in accordance with the raster scan order (36) and, when initializing the symbol probabilities for the context- adaptive entropy decoding of the current slice in accordance with the first mode, it is checked whether the first coding block of the contiguous subset of coding blocks (32) associated with the current slice is the first coding block (32) in a row according to the raster scan order, and if so , then initializing (40) symbol probabilities for context-adaptive entropy decoding of the current slice depending on the stored symbol probabilities obtained in the context-adaptive entropy decoding of the previous decoded slice to the second coding block, in a row in accordance with the raster scan order (36), and if it's not like that initializing (38) symbol probabilities for context-adaptive entropy decoding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy decoding of the previous decoded slice to the end of the previous decoded slice, moreover, in the first and second modes, the predictive decoding is limited within the tiles into which the image is subdivided. 2. The method of claim 1, comprising splitting chroma transform blocks differently than luma transform blocks in response to information in the data stream. 3. The method according to claim 1, wherein the method comprises, as a response to the plot (18) of the syntax element in the current slice of said slices (14), decoding the current slice in accordance with one of at least three modes, namely in one from the first (20) and the third mode (42) or the second mode (22), and according to the third mode (42), the current slice is decoded from the data stream using context-adaptive entropy decoding with context derivation constrained to avoid crossing slice boundaries, continuously updating the symbol probabilities of the contexts, and initializing the symbol probabilities independently of any previously decoded slice, and predictive decoding across slice boundaries, wherein one of the first and third modes is selected depending on the syntax element. 4. A method for encoding an image (10) into a data stream (12) in units of slices (14), into which the image (10) is divided, and the method comprises encoding slices (14) into a data stream (12) in accordance with the order (16) slices, the method comprising the steps of: define a section (18) of the syntax element for the current slice of said slices and encode the section (18) of the syntax element into the current slice, so that the section of the syntax element signals that the current slice is encoded in accordance with one of at least two modes (20, 22 ), and if the current slice is encoded in accordance with the first (20) of the at least two mentioned modes, the current slice is encoded into the data stream (12) using context-adaptive entropy coding (24), which includes deriving contexts across slice boundaries, continuous updating contexts symbol probabilities and initializing (38, 40) the symbol probabilities depending on the stored symbol probabilities states of the previously encoded slice, and cross-slice boundary predictive coding, and if the current slice is encoded in accordance with the second (22) of the at least two mentioned modes, the current slice is encoded into the data stream (12) using context-adaptive entropy coding with context derivation constraint so as not to cross slice boundaries, continuously updating symbol probabilities contexts and initialization of symbol probabilities independently of any previously encoded slice, and predictive coding with predictive coding constraint not to cross slice boundaries, moreover, the image (10) is divided into coding blocks (32) arranged in rows and columns and having a raster scan order (36) defined between them, and the method comprises associating each slice (14) with a continuous subset of coding blocks (32) in the order (36) raster scans such that the subsets follow each other according to the raster scan order (36) according to the slice order, and wherein the method further comprises storing the symbol probabilities obtained by context-adaptive entropy encoding of the previously encoded slice up to the second coding block (32) in a row in accordance with the raster scan order (36) and, when initializing the symbol probabilities for the context - adaptive entropy coding of the current slice in accordance with the first mode, it is checked whether the first coding block of the contiguous subset of coding blocks (32) associated with the current slice is the first coding block (32) in a row in accordance with the raster scan order, and if it is so that initialize (40) symbol probabilities for context-adaptive entropy coding of the current slice depending on the stored symbol probabilities obtained in the context-adaptive entropy coding of the previous encoded slice to the second coding block, in a row in accordance with the raster scan order (36) and, if it's not like that initializing (38) symbol probabilities for context-adaptive entropy coding of the current slice depending on the symbol probabilities obtained by context-adaptive entropy coding of the previous decoded slice to the end of the previous encoded slice, moreover, in the first and second modes, the prediction encoding is limited within the tiles into which the image is subdivided. 5. The method of claim 4, comprising partitioning chroma transform blocks differently than luma transform blocks. 6. A digital data carrier storing a data stream encoded using the method of claim 4. 7. The digital data carrier of claim 6, wherein the chroma transform blocks are partitioned differently than the luma transform blocks. 8. A computer-readable medium storing program code for executing, when it is run on a computer, the method of claim 1. 9. A computer-readable medium storing program code for executing, when it is run on a computer, the method of claim 4. 10. A programmable computer system for encoding/decoding payload data of a sequence of raw bytes, wherein the decoding is performed by the method of claim 1 and the encoding is performed by the method of claim 4.

Images