Context initialization in entropy coding

Abstract

To provide a decoder, etc., for decoding a video from a data stream into which syntax elements are coded using binarizations of syntax elements.SOLUTION: A decoder comprises: an entropy decoder 409 configured to derive bins of binarizations from a data stream using binary entropy decoding; a desymbolizer 314 configured to debinarize the binarizations of the syntax elements to obtain integer values of syntax elements; and a reconstructor 404 configured to reconstruct a video based on the integer values of the syntax elements using a quantization parameter. Therein the entropy decoder is configured to: distinguish between 126 probability states; initialize the probability states associated with the different contexts according to a linear equation of the quantization parameter; and for each of the different contexts, derive a slope and an offset of the linear equation from first and second four bit parts of each of 8 bit initialization values.SELECTED DRAWING: Figure 16

Description

[Technical field]

[0001] The present invention relates to the concept of entropy coding for encoding data. [Background technology]

[0002] A large number of video codecs are known in the art. In general, these codecs reduce the amount of data required to represent video content, i.e., they compress data. In entropy coding, it is crucial to code symbols with probability estimates that correspond as closely as possible to the actual symbol statistics. The probability estimate associates a probability value with each possible value of the symbols to be coded. In the case of binary entropy coding, for example, the symbols are binary in nature and there are only two such possible values. In the case of video coding, the symbols to be coded belong to various syntax elements that perform different tasks to describe the video context: motion vector differences, coding modes, transform coefficient levels representing prediction residuals, etc. First, all of these syntax elements have a different domain of possible values, and even those syntax elements defined on the same domain of possible values ​​are likely to show different frequency of occurrence histograms across this domain of possible values. Therefore, the symbols / bins of the symbol / bin strings of the symbolization / binarization of these syntax elements also show different statistics with respect to the probability distribution over the symbol alphabet. Therefore, a context-adaptive entropy coding is used. First, different contexts are provided, where each context is associated with a different probability estimate. Thus, for example, bins of different syntax elements are likely to be assigned to different contexts. Even the spatial correlation between bins / symbols of syntax elements for adjacent parts of an image of a video may be used to select among the various provided contexts. In this way, the bins / symbols can be classified into groups, whose symbol statistics also change for different video contexts. However, apart from that, the probability estimates associated with these contexts are continuously adapted to the actual symbol statistics during the coding.

[0003] From the above description, it is immediately obvious that it is important to design the contexts carefully and to properly initialize the probability estimates of the contexts. For example, if the number of contexts becomes too large, the adaptation of the probability estimates will fail because the occurrence frequency of each symbol in each context is too low. On the other hand, if the number of contexts is too small, the probability estimates will not be able to closely approximate the actual symbol statistics of all the symbols in each context, because the symbols collected in each context will have different statistics in practice. As far as the initialization of the probability estimates is concerned, it may be obtained from performing a training phase, in which a representative blend of video contents is coded and the sample statistics of the syntax elements are studied. In this case, for example, in H.264, it has been exploited that the symbol statistics of various content symbols of H.264 partially indicate the dependency on the quantization parameter QP that the encoder selects for each slice of the video. That is, in H.264, the initialization of the probability estimates that depends on the quantization parameter has been used. In particular, the H.264 codec defines a pair of values ​​for each context. The first is a linear quantization parameter dependent factor, the slope, and the second is an offset value, an initialization value independent of the quantization parameter. Both values ​​are defined as 8 bits.

[0004] There is a constant demand for further improvements in the coding efficiency of video coding. It would therefore be desirable if the above-mentioned context-adaptive binary entropy coding could be further improved in terms of efficiency, i.e. in a compromise between compression ratio on the one hand and implementation complexity on the other. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] WO2011 / 128268A1 Summary of the Invention [Problem to be solved by the invention]

[0006] SUMMARY OF THE PRESENT EMBODIMENT It is therefore an object of the present invention to provide a coating concept as mentioned above. [Means for solving the problem]

[0007] This object is achieved by the subject matter of the attached independent claims.

[0008] The basic insight of the present invention is based on the inventors' discovery that the precision of the above-mentioned slopes and offsets in the context-adaptive binary entropy coding should not be too high, in order to avoid any training phase in which representative blends of video content are tested to derive the slope-offset pairs for each context from getting stuck on optimum values ​​that in effect more closely represent the blends of video content tested than the representative values ​​of the statistical population of videos. Thus, the inventors of the present invention have found that it is preferable to reduce the precision with which the slope and offset values ​​are provided to initialize the probability estimates of the contexts. The inventors have realized that such a reduction not only results in a reduction in the memory demand imposed on the video encoder and decoder for storing the slope-offset pairs, but also in a slight improvement in the coding efficiency during field testing.

[0009] Preferred embodiments of the present invention will now be described with reference to the drawings. [Brief description of the drawings]

[0010] [Figure 1] 1 shows a block diagram of an encoder according to an embodiment; [Diagram 2] 2A-2C illustrate diagrammatically various subdivisions of a sample array, such as a picture, into blocks. [Diagram 3] FIG. 2 shows a block diagram of a decoder according to an embodiment. [Figure 4] 1 shows a block diagram of an encoder according to an embodiment in further detail. [Diagram 5] 1 shows a block diagram of a decoder according to one embodiment in further detail. [Figure 6] 1 illustrates diagrammatically the transformation of a block from the spatial domain to the spectral domain and the resulting transformed block and its retransformation. [Figure 7] 1 shows a block diagram of an encoder according to an embodiment; [Figure 8] 9 shows a block diagram of a decoder according to one embodiment suitable for decoding the bitstream produced by the encoder of FIG. 8. [Figure 9] FIG. 2 is a schematic diagram illustrating a data packet according to an embodiment having multiplexed partial bitstreams. [Figure 10] FIG. 11 is a schematic diagram illustrating a data packet according to another embodiment having an alternative segmentation using fixed size segments. [Figure 11] 1 shows a decoder according to an embodiment that supports mode switching. [Figure 12] 4 shows a decoder according to another embodiment supporting mode switching; [Figure 13] 12 shows an encoder according to an embodiment, which is compatible with the decoder of FIG. [Figure 14] 13 shows an encoder according to an embodiment that is compatible with the decoder of FIG. 12. [Figure 15] This shows the mapping between pStateCtx and fullCtxState / 256. [Figure 16] 2 shows a decoder according to an embodiment of the present invention; [Figure 17] 2 illustrates an encoder according to an embodiment of the present invention; DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0011] In describing the figures, elements that appear in several of these figures are designated by the same reference numerals in each of those figures and, to avoid unnecessary repetition, repeated description of those elements, insofar as their function is concerned, is omitted. However, the functions and descriptions given with respect to one figure shall apply to the other figures, unless expressly stated otherwise.

[0012] In the following, first an embodiment of the overall video encoding concept is described with reference to figures 1 to 17. Figures 1 to 6 relate to the part of the video codec operating at the syntax level. The following figures 8 to 17 relate to an embodiment of the encoding part relating to the conversion of syntax element streams to data streams and vice versa. Specific aspects and embodiments of the present invention are then described as possible implementations of the overall concept described with reference to figures 1 to 17.

[0013] FIG. 1 illustrates an example of an encoder 10 in which aspects of the present invention may be implemented.

[0014] The encoder encodes the array of information samples 20 into a data stream. The array of information samples may represent information samples corresponding to, for example, brightness values, color values, luminance values, chroma values, etc. However, the information samples may also be depth values, in which case the sample array 20 is, for example, a depth map generated by a time of a light sensor, etc.

[0015] The encoder 10 is a block-based encoder, i.e., the encoder 10 encodes the sample array 20 into the data stream 30 in units of blocks 40. Encoding in units of blocks 40 does not necessarily mean that the encoder 10 encodes these blocks 40 completely independently of one another. Rather, the encoder 10 may use reconstructions of previously encoded blocks to extrapolate or intra-predict the remaining blocks, and may use the block granularity to set the encoding parameters, i.e., how each sample array region corresponding to a respective block is coded.

[0016] Also, the encoder 10 is a transform coder, i.e., the encoder 10 encodes the blocks 40 using a transform to transfer the information samples in each block 40 from the spatial domain to the spectral domain. A two-dimensional transform such as the DCT of an FFT may be used. Preferably, the blocks 40 are square or rectangular.

[0017] The subdivision of sample array 20 into blocks 40 shown in Figure 1 is for illustrative purposes only. Figure 1 shows sample array 20 as being subdivided into a regular two-dimensional arrangement of non-overlapping adjacent square or rectangular blocks 40. The size of blocks 40 may be predetermined, i.e., encoder 10 need not transmit information about the block size of blocks 40 to the decoding side in data stream 30. For example, the decoder may expect the predetermined block size.

[0018] However, several alternatives are possible. For example, blocks may overlap each other, but the degree of overlap is limited so that each block has a part that does not overlap any neighboring block, or each sample of a block overlaps at most one neighboring block that is arranged juxtaposed to the current block along a given direction. The latter means that the left and right neighboring blocks can overlap completely covering the current block, but the neighboring blocks themselves do not overlap each other. The same applies to vertical and diagonal adjacencies.

[0019] As a further alternative, the subdivision of the sample array 20 into blocks 40 may be applied to the contents of the sample array 20 by the encoder 10 and the subdivision information used in the subdivision may be transferred via the bitstream 30 to the decoder side.

[0020] 2a-2c show different examples of subdivision of the sample array 20 into blocks 40. FIG. 2a shows a quadtree-based subdivision of the sample array 20 into blocks 40 of different sizes, where representative blocks are shown by 40a, 40b, 40c and 40d, in order of increasing size. According to the subdivision of FIG. 2a, the sample array 20 is first divided into a regular two-dimensional arrangement of tree blocks 40d. These tree blocks 40d have associated therewith respective subdivision information regarding whether a certain tree block 40d is further subdivided according to the quadtree structure. The tree block to the left of the block 40d is exemplarily further subdivided according to the quadtree structure into smaller blocks. The encoder 10 may perform one two-dimensional transform for each of the blocks shown in FIG. 2a with solid and dashed lines. In other words, the encoder 10 may transform the array 20 in units of block subdivisions.

[0021] Instead of quadtree-based subdivision, a more general bitree-based subdivision may be used, and the number of child nodes per hierarchical level may vary between different hierarchical levels.

[0022] Fig. 2b shows another example of subdivision. According to Fig. 2b, the sample array 20 is first divided into non-overlapping adjacent regular two-dimensionally arranged macroblocks 40b, where each macroblock 40b has associated thereto subdivision information by which the macroblock is either not subdivided or, if subdivided, sub-divided into equal-sized subblocks in a regular two-dimensional manner such that different subdivision granularities are achieved for different macroblocks. The result is a subdivision of the sample array 20 into blocks 40 of different sizes, representative examples of different sizes being shown at 40a, 40b and 40a'. As shown in Fig. 2a, the encoder 10 performs a two-dimensional transform on each of the blocks shown in Fig. 2b with solid and dashed lines. Fig. 2c is described below.

[0023] 3 shows a decoder 50 capable of decoding the data stream 30 produced by the encoder 10 to recover a reconstructed version 60 of the sample array 20. The decoder 50 recovers the reconstructed version 60 by extracting transform coefficient blocks for each of the blocks 40 from the data stream 30 and performing an inverse transform on each of the transform coefficient blocks.

[0024] The encoder 10 and the decoder 50 may be configured to perform entropy coding / decoding, respectively, to insert and extract information about the transform coefficient blocks from the data stream, as will be described in more detail below. It should be noted that the data stream 30 does not necessarily include transform coefficient block information for all blocks 40 of the sample array 20. Rather, a subset of the blocks 40 may be coded in the bitstream 30 in other ways. For example, the encoder 10 may decide not to insert transform coefficient blocks for some of the blocks 40, and instead insert alternative coding parameters in the bitstream 30 to allow the decoder 50 to predict or fill the respective block in the reconstructed version 60. For example, the encoder 10 may perform texture analysis to locate the blocks in the sample array 20, and indicate this appropriately in the bitstream, so that the decoder can perform texture synthesis at the decoding side to fill the sample array 20.

[0025] As will be explained in the following figures, the transform coefficient blocks do not necessarily represent a spectral domain representation of the original information samples of each block 40 of the sample array 20. Rather, such transform coefficient blocks may represent a spectral domain representation of a prediction residual of each block 40. FIG. 4 shows an embodiment of such an encoder. The encoder of FIG. 4 comprises a transform stage 100, an entropy coder 102, an inverse transform stage 104, a predictor 106, a subtractor 108 and an adder 110. The subtractor 108, the transform stage 100 and the entropy coder 102 are connected in series, in that order, between an input 112 and an output 114 of the encoder of FIG. 4. The inverse transform stage 104, the adder 110 and the predictor 106 are connected in that order between the output of the transform stage 100 and an inverting input of the subtractor 108, the output of the predictor 106 also being connected to the other input of the adder 110.

[0026] The coder of Fig. 4 is a predictive transform-based block coder, i.e., blocks of the sample array 20 entering the input 112 are predicted from previously coded and reconstructed parts of the same sample array 20, or from other previously coded and reconstructed sample arrays that may precede or follow the current sample array 20 in performance time. The prediction is performed by a predictor 106. A subtractor 108 subtracts the prediction value from such original block, and a transform stage 100 performs a two-dimensional transform on the prediction residual. The two-dimensional transform itself or subsequent processing in the transform stage 100 may lead to quantization of the transform coefficients in the transform coefficient block. The quantized transform coefficient block is losslessly coded, for example by entropy coding in an entropy coder 102, and the resulting data stream is output at an output 114. The inverse transform stage 104 reconstructs the quantized residual, and the subsequent adder 110 combines the reconstructed residual with the corresponding prediction to obtain reconstructed information samples, based on which the predictor 106 can predict the currently coded prediction block mentioned above. The predictor 106 may use different prediction modes, such as intra- and inter-prediction modes, to predict the block, and the prediction parameters are sent to the entropy coder 102 for insertion into the data stream. For each inter-predicted prediction block, the respective motion data is inserted into the bitstream via the entropy coder 114, allowing the decoding side to reproduce the prediction. The motion data for the prediction blocks of the picture may include a syntax part including a syntax element representing a motion vector difference, which may differentially code the motion vector for the current prediction block in comparison with a motion vector prediction value derived in a predetermined manner, for example, from the motion vector of a neighboring already coded prediction block.

[0027] That is, according to the embodiment of Figure 4, the transform coefficient block represents a spectral representation of a residual of the sample array, rather than the actual information samples of the sample array. That is, according to the embodiment of Figure 4, a sequence of syntax elements may be input to the entropy encoder 102 for entropy encoding into the data stream 114. The sequence of syntax elements may include, for the transform block, a syntax element for motion vector differences for inter-predicted blocks, a significance map indicating the location of the significant transform coefficient levels, and syntax elements defining the significant transform coefficient levels themselves.

[0028] It should be noted that there are several alternatives to the embodiment of FIG. 4, some of which are described in the introductory part of the specification and which are hereby incorporated into the description of FIG.

[0029] Figure 5 shows a decoder capable of decoding the data stream generated by the encoder of Figure 4. The decoder of Figure 5 comprises an entropy decoder 150, an inverse transform stage 152, an adder 154 and a predictor 156. The entropy decoder 150, the inverse transform stage 152 and the adder 154 are connected in series, in that order, between an input 158 ​​and an output 160 of the decoder of Figure 5. The other output of the entropy decoder 150 is connected to the predictor 156, which in turn is connected between the output of the adder 154 and the other input. The entropy decoder 150 extracts transform coefficient blocks from the data stream entering the decoder of Figure 5 at input 158, where an inverse transform is applied to the transform coefficient blocks at stage 152 to obtain a residual signal. The residual signal is combined with a prediction from the predictor 156 at the adder 154 to obtain a reconstructed block of a reconstructed version of the sample array at output 160. Based on the reconstructed version, a predictor 156 generates a prediction, thereby reconstructing the prediction performed by predictor 106 on the encoder side. To obtain the same prediction as that used on the encoder side, predictor 156 uses prediction parameters that the entropy decoder 150 obtained from the data stream at input 158.

[0030] It should be noted that in the above embodiment, the spatial granularity at which the residual prediction and transformation are performed may not be equal to each other. This is shown in FIG. 2C, which shows the subdivision of the prediction block of prediction granularity in solid lines and the residual granularity in dashed lines. As can be seen, the subdivisions may be selected by the encoder independent of each other. More precisely, the syntax of the data stream allows the definition of the residual subdivision independent of the prediction subdivision. Alternatively, the residual subdivision may be an extension of the prediction subdivision, with each residual block being equal to the prediction block or a suitable subset thereof. This is shown for example in FIG. 2a and FIG. 2b. Again, the prediction granularity is shown in solid lines and the residual granularity in dashed lines. That is to say, in FIG. 2a-FIG. 2c, all blocks marked with reference numbers are residual blocks for which one two-dimensional transformation is performed, while the larger solid block encompassing the dashed block 40a is, for example, a prediction block for which a prediction parameter setting is performed individually.

[0031] The above-mentioned embodiments have in common that a block of (residual or original) samples is transformed at the encoder side into a block of transform coefficients, which is then transformed back at the decoder side into a reconstructed block of samples. This is illustrated in FIG. 6. FIG. 6 shows a block of samples 200. In the case of FIG. 6, the block 200 is exemplarily a two-dimensional block of samples 202 of size 4·4. The samples 202 are regularly arranged along the horizontal direction x and along the vertical direction y. By the above-mentioned two-dimensional transform T, the block 200 is transformed into the spectral domain, i.e. into a block 204 of transform coefficients 206, where the transform block 204 has the same size as the block 200. That is to say, the transform block 204 has as many transform coefficients 206 in both the horizontal and vertical directions as the block 200 has samples. However, since the transform T is a spectral transform, the positions of the transform coefficients 206 in the transform block 204 correspond to the spectral content, rather than to the spatial position of the content of the block 200. In particular, the horizontal axis of the transform block 204 corresponds to an axis along which the horizontal spectral frequency increases monotonically, and the vertical axis corresponds to an axis along which the vertical spatial frequency increases monotonically, with the DC component transform coefficients located at the corners of the block 204, here illustratively the top left corner, such that the transform coefficients 206 corresponding to the highest frequencies in both the horizontal and vertical directions are located at the bottom right corner. Ignoring spatial direction, the spatial frequency to which a given transform coefficient 206 belongs generally increases from the top left corner to the bottom right corner. -1 By , the transformed block 204 is retransmitted from the spectral domain to the spatial domain to reobtain a replica 208 of the block 200. If no quantization / loss is introduced during the transformation, the reconstruction will be perfect.

[0032] As already mentioned above, it can be seen from Fig. 6 that the spectral resolution of the resulting spectral representation 204 increases when the block size of the block 200 is increased. On the other hand, quantization noise tends to spread over the whole block 208, so that abrupt and very local objects in the block 200 tend to cause deviations in the retransformed block compared to the original block 200 due to quantization noise. However, the main advantage of using larger blocks is that in larger blocks compared to smaller blocks, the ratio between the number of significant, i.e. non-zero (quantized) transform coefficients, i.e. levels, on the one hand, and the number of non-significant transform coefficients on the other hand, can be reduced, thus allowing a better coding efficiency. In other words, often the significant transform coefficient levels, i.e. transform coefficient levels that are not quantized to zero, are sparsely distributed over the transform block 204. Therefore, according to an embodiment described in more detail hereinafter, the location of the significant transform coefficient levels is signaled in the data stream by a significance map. Separately, the values ​​of the significant transform coefficients, ie the transform coefficient levels if the transform coefficients are quantized, are transmitted in the data stream.

[0033] Therefore, all the above mentioned encoders and decoders are configured to handle a predefined syntax of syntax elements, i.e. it is assumed that the above mentioned syntax elements such as transform coefficient levels, syntax elements related to significance maps of transform blocks, syntax elements of motion data related to inter-prediction blocks, etc. are consecutively arranged in a predefined manner in the data stream. Such a predefined manner may be expressed for example in the form of a pseudocode as is done in the H264 standard or other video codecs.

[0034] In other words, the above description mainly deals with the conversion of media data, here exemplarily video data, into a sequence of syntax elements according to a predefined syntax structure that specifies certain syntax element types, their semantics and the ordering between them. The entropy encoders and decoders of figures 4 and 5 may operate and be configured as follows. They are responsible for performing the conversion between a sequence of syntax elements and a data stream, i.e. a stream of symbols or bits.

[0035] An entropy encoder according to an embodiment of the present invention is shown in Figure 7. The encoder losslessly converts a stream of syntax elements 301 into a set of two or more partial bitstreams 312.

[0036] In a preferred embodiment of the present invention, each syntax element 301 is associated with one or more categories, i.e., a set of syntax element types. As an example, a category may specify the type of the syntax element. In the context of hybrid video coding, separate categories may be associated with macroblock coding modes, block coding modes, reference picture indices, motion vector differences, sub-partition flags, coded block flags, quantization parameters, transform coefficient levels, etc. Different classifications of syntax elements are possible in other application areas, such as audio, speech, text, documents, or general data coding.

[0037] In general, each syntax element can take on a finite or countably infinite set of values, where the set of possible syntax element values ​​can be different for different syntax element categories, e.g., there are binary syntax elements as well as integer-valued syntax elements.

[0038] To reduce the complexity of the encoding and decoding algorithms and to allow the design of generic encoding and decoding for various syntax elements and syntax element categories, the syntax elements 301 are converted into an ordered set of binary decisions, which are then processed by a simple binary encoding algorithm. To do so, the binarizer 302 bijectively maps the values ​​of each syntax element 301 into a sequence of bins 303 (or strings or words). The sequence of bins 303 represents a set of ordered binary decisions. Each bin 303 or binary decision can take one value out of a set of two values, e.g. one of the values ​​0 and 1. The binarization scheme may be different for different syntax element categories. The binarization scheme for a particular syntax element category may depend on the set of possible syntax element values ​​for that particular category and / or other characteristics of the syntax elements.

[0039] Table 1 shows three exemplary binarization schemes for countably infinite sets. These binarization schemes for countably infinite sets can also be applied to finite sets of syntax element values. In particular, for large finite sets of syntax element values, the generality of such binarization schemes offers advantages in terms of complexity and memory requirements, while inefficiencies (arising from unused bin sequences) can be neglected. For small finite sets of syntax element values, it is often preferable (in terms of coding efficiency) to adapt the binarization scheme to the number of possible symbol values.

[0040] Table 2 shows three example binarization schemes for finite sets of eight values. A binarization scheme for a finite set can be derived from the universal binarization scheme for countably infinite sets by modifying some of the bin sequences so that the finite set of bin sequences represents a code without redundancy (and potentially by permuting the bin sequences). For example, the truncated unary binarization scheme in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal unary binarization (see Table 1). The truncated and permuted exponential-Golomb binarization of degree 0 in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal exponential-Golomb order 0 (see Table 1) and by permuting the bin sequence (the truncated bin sequence for symbol 7 was assigned to symbol 1). For finite sets of syntax elements, it is also possible to use non-systematic / non-universal binarization schemes, as illustrated in the last column of Table 2.

[0041] [Table 1]

[0042] [Table 2]

[0043] Each bin 303 of the bin string created by the binarizer 302 is passed in turn to a parameter assigner 304, which assigns a set of one or more parameters to each bin 303 and outputs a bin 305 with the associated set of parameters. The set of parameters is determined in exactly the same way in the encoder and in the decoder. The set of parameters may consist of one or more of the following parameters:

[0044] In particular, the parameter assigner 304 may be configured to assign a context model to the current bin 303. For example, the parameter assigner 304 may select one of the valid context indexes for the current bin 303. The set of valid contexts for the current bin 303 may depend on the type of the bin, which may be defined by the type / category of the syntax element 301, the binarization of which the current bin 303 is part, and the position of the current bin 303 within that binarization. The selection of a context from the set of valid contexts may depend on the previous bin and the syntax element associated with that bin. Each of these contexts has a probability model associated with it, i.e. a measure of probability estimate for one of two possible bin values ​​for the current bin. The probability model may in particular be a measure of probability estimate for a bin value with a minority or majority probability for the current bin, and may further be defined by an identifier specifying an estimate of which of the two possible bin values ​​represents the bin value with a minority or majority probability for the current bin 303. If only one context is valid for the current bin, no context selection may be performed. As will be described in more detail below, the parameter assigner 304 may perform probability model adaptation to adapt the probability models associated with different contexts to the actual bin statistics of each bin belonging to the respective context.

[0045] Also, as will be explained in more detail below, the parameter assigner 304 may operate differently depending on whether a high efficiency (HE) mode or a low complexity (LC) mode is activated. In both modes, a probabilistic model associates the current bin 303 to one of the bin encoders 310 as described below. In this case, the operating mode of the parameter assigner 304 tends to be less complex in the LC mode, but the coding efficiency is higher in the high efficiency mode, because the parameter assigner 304 associating each bin 303 to each encoder 310 is more accurately adapted to the bin statistics, resulting in a more entropy-optimized than in the LC mode.

[0046] Each bin 305 with its associated set of parameters that is output by the parameter assigner 304 is sent to a bin buffer selector 306. The bin buffer selector 306 potentially modifies the value of the input bin 305 based on the input bin value and its associated parameters 305, and sends the output bin 307 (with potentially modified value) to one of two or more bin buffers 308. The bin buffer 308 to which the output bin 307 is sent is determined based on the value of the input bin 305 and / or the value of the associated parameters 305.

[0047] In a preferred embodiment of the present invention, the bin buffer selector 306 does not change the bin values, i.e. the output bin 307 always has the same value as the input bin 305. In a further preferred embodiment of the present invention, the bin buffer selector 306 determines the output bin value 307 based on the input bin value 305 and an associated measure for the probability estimate for one of the two possible bin values ​​for the current bin. In a preferred embodiment of the present invention, the output bin value 307 is set equal to the input bin value 305 if the measure of probability for one of the two possible bin values ​​for the current bin is below (or equal to) a certain threshold, whereas the output bin value 307 is changed (i.e. set to the inverse of the input bin value) if the measure of probability for one of the two possible bin values ​​for the current bin is above (or equal to) a certain threshold. In a further preferred embodiment of the invention, the output bin value 307 is set equal to the input bin value 305 if the probability measure for one of the two possible bin values ​​for the current bin is greater than (or equal to) a certain threshold, whereas the output bin value 307 is modified (i.e. set to the inverse of the input bin value) if the probability measure for one of the two possible bin values ​​for the current bin is less than (or equal to) a certain threshold. In a preferred embodiment of the invention, the threshold corresponds to a value of 0.5 for the estimated probabilities of both possible bin values.

[0048] In a further preferred embodiment of the present invention, the bin buffer selector 306 determines an output bin value 307 based on the input bin value 305 and an associated identifier specifying an estimate of which of the two possible bin values ​​represents the bin value with the inferior or superior probability with respect to the current bin. In a preferred embodiment of the present invention, if the identifier specifies that the first of the two possible bin values ​​represents the bin value with the inferior (or superior) probability with respect to the current bin, the output bin value 307 is set to a value equal to the input bin value 305, whereas if the identifier specifies that the second of the two possible bin values ​​represents the bin value with the inferior (or superior) probability with respect to the current bin, the output bin value 307 is modified (i.e. set to the inverse of the input bin value).

[0049] In a preferred embodiment of the present invention, the bin buffer selector 306 determines the bin buffer 308 to which the output bin 307 is sent based on the associated measure for the probability estimation for one of the two possible bin values ​​for the current bin. In a preferred embodiment of the present invention, the set of possible values ​​for the measure of the probability estimation for one of the two possible bin values ​​is finite and the bin buffer selector 306 includes a table associating exactly one bin buffer 308 for each possible value for the probability estimation for one of the two possible bin values, where different values ​​of the measure of the probability estimation for one of the two possible bin values ​​can be associated for the same bin buffer 308. In a further preferred embodiment of the invention, the range of possible values ​​for the measure of the probability estimation for one of the two possible bin values ​​is partitioned into several intervals, the bin buffer selector 306 determines an interval index for the current measure of the probability estimation for one of the two possible bin values, and further the bin buffer selector 306 comprises a table associating exactly one bin buffer 308 with each possible value for this interval index, where different values ​​for the interval index can be associated to the same bin buffer 308. In a preferred embodiment of the invention, input bins 305 with the inverse measure of the probability estimation for one of the two possible bin values ​​(the inverse measure being a measure representing the probability estimates P and 1-P) are fed to the same bin buffer 308. In a further preferred embodiment of the invention, the association of the measure of the probability estimation for one of the two possible bin values ​​for the current bin to a particular bin buffer is adapted over time, for example to ensure that the created partial bitstreams have similar bitrates. In the following, the interval index is also called the pipe index, which together with the refinement index and a flag indicating the bin value with the dominant probability, points to the actual probability model, i.e. the probability estimate.

[0050] In a preferred embodiment of the present invention, the bin buffer selector 306 determines the bin buffer 308 to which to send the output bin 307 based on the associated scale for the probability estimation of the bin value with the inferior or superior probability with respect to the current bin. In a preferred embodiment of the present invention, the set of possible values ​​for the scale for the probability estimation of the bin value with the inferior or superior probability is finite, and the bin buffer selector 306 includes a table that associates exactly one bin buffer 308 with each possible value of the probability estimation for the bin value with the inferior or superior probability, where different values ​​for the scale of the probability estimation for the bin value with the inferior or superior probability can be associated for the same bin buffer 308. In a further preferred embodiment of the invention, the range of possible values ​​for the measure of probability estimation for bin values ​​with inferior or superior probability is partitioned into several intervals, the bin buffer selector 306 determines an interval index for the current measure for probability estimation for bin values ​​with inferior or superior probability, and further the bin buffer selector 306 comprises a table associating one bin buffer 308 with each possible value for this interval index, in which different values ​​for the interval index can be associated for the same bin buffer 308. In a further embodiment of the invention, the association of the measure of probability estimation for bin values ​​with inferior or superior probability with respect to the current bin to a particular bin buffer is adapted over time, e.g. to ensure that the created partial bitstreams have similar bitrates.

[0051] Each of the two or more bin buffers 308 is connected to one bin encoder 310, and each bin encoder is connected to only one bin buffer 308. Each bin encoder 310 reads bins from the associated bin buffer 308 and converts the bin sequence 309 into a codeword 311 representing a bit sequence. The bin buffers 308 represent a first-in, first-out buffer, i.e., bins sent later (in the order) to the bin buffer 308 are not encoded before bins sent earlier (in the order) to the bin buffer 308. The output of a particular bin encoder 310, a codeword 311, is written to a particular partial bitstream 312. The overall encoding algorithm converts the syntax element 301 into two or more partial bitstreams 312, where the number of partial bitstreams is equal to the number of bin buffers and bin encoders. In a preferred embodiment of the present invention, the bin encoder 310 converts a variable number of bins 309 into a codeword 311 consisting of a variable number of bits. One advantage of the embodiments of the present invention outlined above and below is that the encoding of bins (e.g., for each group with a different probability measure) can be performed in parallel, thereby reducing processing time in some implementations.

[0052] Another advantage of the present invention is that the bin coding performed by the bin coder 310 can be specially designed for different sets of parameters 305. In particular, the bin coding and encoding can be optimized (in terms of coding efficiency and / or complexity) for different groups of estimated probabilities. On the one hand, this advantage allows a reduction in the coding / decoding complexity. On the other hand, it allows an increase in coding efficiency. In a preferred embodiment of the present invention, the bin coder 310 implements different coding algorithms (i.e. a mapping of the bin sequence to codewords) for different groups of measures of probability estimates for one of the two possible bin values ​​5 with respect to the current bin. In a further preferred embodiment of the present invention, the bin coder 310 implements different coding algorithms for different groups of measures of probability estimates for bin values ​​with inferior or superior probabilities with respect to the current bin.

[0053] In a preferred embodiment of the present invention, the multiple bin encoder 310 - or one or more bin encoders - represents an entropy encoder that directly maps the input bin sequence 309 to codewords 311. Such a mapping can be implemented efficiently and does not require a complex arithmetic coding engine. Although the inverse mapping of codewords to bin sequences (as done in a decoder) needs to be unique to ensure perfect decoding of the input sequence, the mapping of bin sequence 309 to codewords 311 does not necessarily need to be unique. That is, it is possible that one particular bin sequence is mapped to more than one sequence of codewords. In a preferred embodiment of the present invention, the mapping of input bin sequence 309 to codewords 311 is bijective. In a further preferred embodiment of the present invention, the multiple bin encoder 310 - or one or more bin encoders - represents an entropy encoder that directly maps a variable length input bin sequence 309 to variable length codewords 311. In a preferred embodiment of the present invention, the output codewords represent redundancy-free codes such as general Huffman codes or canonical Huffman codes.

[0054] Two examples for bijectively mapping bin sequences to redundancy-free codes are shown in Table 3. In a further preferred embodiment of the invention, the output codeword represents a code with redundancy suitable for error detection and recovery. In a further preferred embodiment of the invention, the output codeword represents an encryption code suitable for encrypting syntax elements.

[0055] [Table 3]

[0056] In a further preferred embodiment of the present invention, multiple bin encoder 310 - or one or more bin encoders - represents an entropy encoder that directly maps a variable length input bin sequence 309 to fixed length codewords 311. In a further preferred embodiment of the present invention, multiple bin encoder 310 (or one or more bin encoders) represents an entropy encoder that directly maps a fixed length input bin sequence 309 to variable length codewords 311.

[0057] A decoder according to an embodiment of the present invention is shown in Figure 8. The decoder essentially performs the inverse operations of the encoder described above, whereby a (previously encoded) sequence of syntax elements 327 is decoded from a collection of two or more partial bitstreams 324. The decoder includes two different processing flows: a flow for data requests that replicates the data flow of the encoder, and a data flow that represents the inverse of the encoder data flow. In Figure 8, the dashed arrows represent the data request flow, while the solid arrows represent the data flow. The building blocks of the decoder essentially replicate the building blocks of the encoder, but perform the inverse operations.

[0058] The decoding of a syntax element is triggered by a request for a new decoded syntax element 313 sent to the binarizer 314. In a preferred embodiment of the present invention, each request for a new decoded syntax element 313 is associated with one category of a set of one or more categories. The category associated with the request for this syntax element is the same as the category that was associated with the corresponding syntax element during encoding.

[0059] The binarizer 314 maps the request for syntax elements 313 into one or more requests for bins that are sent to the parameter assigner 316. As a final response to a request for bins sent by the binarizer 314 to the parameter assigner 316, the binarizer 314 receives decoded bins 326 from the bin buffer selector 318. The binarizer 314 compares the received sequence of decoded bins 326 with the bin sequence of the particular binarization scheme for the requested syntax element, and if the received sequence of decoded bins 326 matches the binarization of the syntax element, the binarizer empties its bin buffer and outputs the decoded syntax element as a final response to a request for a new decoded symbol. If the already received decoded bin sequence does not match any of the bin sequences of the binarization scheme for the requested syntax element, the binarizer sends another request for bins to the parameter assigner until the decoded bin sequence matches one of the bin sequences of the binarization scheme for the requested syntax element. For each request for a syntax element, the decoder uses the same binarization scheme as that used to encode the corresponding syntax element. The binarization scheme may be different for different syntax element categories. The binarization scheme for a particular syntax element category may depend on the set of possible syntax element values ​​and / or other characteristics of the syntax elements for the particular category.

[0060] The parameter assigner 316 assigns one or more sets of parameters to each request for a bin and sends the request for the bin and its associated set of parameters to the bin buffer selector. The set of parameters assigned by the parameter assigner to a requested bin is the same as that assigned to the corresponding bin during encoding. This set of parameters may consist of one or more of the parameters described above in the description of the encoder of FIG. 7.

[0061] In a preferred embodiment of the present invention, the parameter assigner 316 associates with each request for a bin similar parameters as the assigner 304 does, i.e., a context and its associated measure, such as a measure of a probability estimate for one of two possible bin values ​​for the currently requested bin, such as a measure of a probability estimate for a bin value having a less favorable or more favorable probability for the currently requested bin, or an identifier specifying an estimate of which of the two possible bin values ​​represents the bin value having a less favorable or more favorable probability for the currently requested bin.

[0062] The parameter assigner 316 may determine one or more of the above probability measures (a probability estimate measure for one of two possible bin values ​​for the currently requested bin, a probability estimate measure for a bin value with a less-probable or more-probable probability for the currently requested bin, and an identifier specifying an estimate of which of the two possible bin values ​​represents the bin value with a less-probable or more-probable probability for the currently requested bin) based on a set of one or more previously decoded symbols. The determination of the probability measure for a particular request for a bin replicates the processing in the encoder for the corresponding bin. The decoded symbols used to determine the probability measure may include one or more previously decoded symbols of the same symbol category, one or more previously decoded symbols of the same symbol category corresponding to a data set (e.g., a block or group of samples) that is adjacent in space and / or time (with respect to the data set associated with the current request for the syntax element), or one or more previously decoded symbols of a different symbol category corresponding to a data set that is the same and / or adjacent in space and / or time (with respect to the data set associated with the current request for the syntax element).

[0063] Each request for a bin 317 with an associated set of parameters, which is the output of the parameter assigner 316, is sent into a bin buffer selector 318. Based on the set of associated parameters 317, the bin buffer selector 318 sends a request for a bin 319 towards one of two or more bin buffers 320 and receives a decoded bin 325 from the selected bin buffer 320. The decoded input bin 325 is potentially modified, and a decoded output bin 326 - with potentially modified values ​​- is sent to the binarizer 314 as a final response to the request for a bin 317 with an associated set of parameters.

[0064] The way in which the bin buffer 320 to which the request for a bin should be sent is selected is similar to the way in which the bin buffer to which the output bins of the bin buffer selector should be sent at the encoder side is selected.

[0065] In a preferred embodiment of the present invention, the bin buffer selector 318 determines the bin buffer 320 to which the request 319 for a bin should be sent based on the associated measure of the probability estimate for one of the two possible bin values ​​for the currently requested bin. In a preferred embodiment of the present invention, the set of possible values ​​for the measure of the probability estimate for one of the two possible bin values ​​is finite, and the bin buffer selector 318 includes a table that associates exactly one bin buffer 320 with each possible value of the probability estimate for one of the two possible bin values, where different values ​​for the measure of the probability estimate for one of the two possible bin values ​​can be associated with the same bin buffer 320. In a further preferred embodiment of the present invention, the range of possible values ​​for the scale of the probability estimation for one of the two possible bin values ​​is partitioned into a number of intervals, and the bin buffer selector 318 determines an interval index for the current scale of the probability estimation for one of the two possible bin values, and further, the bin buffer selector 318 includes a table associating exactly one bin buffer 320 with each possible value of the interval index, where different values ​​of the interval index can be associated with the same bin buffer 320. In a preferred embodiment of the present invention, requests 317 for bins with opposite scales for the probability estimation for one of the two possible bin values ​​(opposite scales being scales representing the probability estimates P and 1-P) can be forwarded to the same bin buffer 320. In a further preferred embodiment of the present invention, the association of a scale of the probability estimation for one of the two possible bin values ​​for a current bin request with a particular bin buffer can be adapted over time.

[0066] In a further preferred embodiment of the present invention, the bin buffer selector 318 may determine the bin buffer 320 to which the request for a bin 319 should be sent based on the associated measure of probability estimation for the bin value with the inferior or superior probability for the currently requested bin. In a preferred embodiment of the present invention, the set of possible values ​​of the measure of probability estimation for the bin value with the inferior or superior probability is finite and the bin buffer selector 318 includes a table that associates exactly one bin buffer 320 with each possible value of probability estimation for the bin value with the inferior or superior probability, where different values ​​of the measure of probability estimation for the bin value with the inferior or superior probability can be associated with the same bin buffer 320. In a further preferred embodiment of the present invention, the range of possible values ​​for the measure of probability estimation for bin values ​​with inferior or superior probabilities is partitioned into a number of intervals, and the bin buffer selector 318 determines an interval index for the current measure of probability estimation for bin values ​​with inferior or superior probabilities, and further the bin buffer selector 318 includes a table that associates exactly one bin buffer 320 with each possible value of the interval index, where different values ​​of the interval index can be associated with the same bin buffer 320. In a further preferred embodiment of the present invention, the association of the measure of probability estimation for bin values ​​with inferior or superior probabilities for the currently requested bin with a particular bin buffer is adapted over time.

[0067] After receiving the decoded bins 325 from the selected bin buffer 320, the bin buffer selector 318 potentially modifies the input bins 325 and sends the output bins 326—potentially with modified values—to the binarizer 314. The input / output bin mapping of the bin buffer selector 318 is the inverse of the input / output bin mapping of the bin buffer selector on the encoder side.

[0068] In a preferred embodiment of the present invention, the bin buffer selector 318 is configured to not change the bin values, i.e. the output bin 326 always has the same value as the input bin 325. In a further preferred embodiment of the present invention, the bin buffer selector 318 determines the output bin value 326 based on the input bin value 325 and a measure of probability estimate for one of the two possible bin values ​​for a currently requested bin associated with the request for a bin 317. In a preferred embodiment of the present invention, if the measure of probability for one of the two possible bin values ​​for the current bin request is below (or equal to) a certain threshold, the output bin value 326 is set equal to the input bin value 325, whereas, if the measure of probability for one of the two possible bin values ​​for the current bin request is above (or greater than) a certain threshold, the output bin value 326 is changed (i.e. set to the inverse of the input bin value). In a further preferred embodiment of the present invention, the output bin value 326 is set equal to the input bin value 325 if the probability measure for one of the two possible bin values ​​for the current bin request is greater than (or equal to) a certain threshold, whereas the output bin value 326 is modified (i.e. set to the inverse of the input bin value) if the probability measure for one of the two possible bin values ​​for the current bin request is less than (or equal to) a certain threshold. In a preferred embodiment of the present invention, the threshold corresponds to a value of 0.5 for the estimated probabilities for both possible bin values.

[0069] In a further preferred embodiment of the present invention, the bin buffer selector 318 determines an output bin value 326 based on an input bin value 325 and an identifier associated with the request for a bin 317 and specifying an estimate of which of the two possible bin values ​​represents the bin value having the least favorable or most favorable probability for the current bin request. In a preferred embodiment of the present invention, if the identifier specifies that the first of the two possible bin values ​​represents the bin value having the least favorable or most favorable probability for the current bin request, then the output bin value 326 is set equal to the input bin value 325, whereas if the identifier specifies that the second of the two possible bin values ​​represents the bin value having the least favorable or most favorable probability for the current bin request, then the output bin value 326 is modified (i.e., set to the inverse of the input bin value).

[0070] As described above, the bin buffer selector sends requests for bins 319 to one of two or more bin buffers 320. The bin buffer 320 represents a first-in, first-out buffer that receives a sequence of decoded bins 321 from an attached bin decoder 322. In response to a request for bins 319 sent from the bin buffer selector 318 to the bin buffer 320, the bin buffer 320 removes the bin of its contents that was sent to the bin buffer 320 first and sends it to the bin buffer selector 318. Bins sent to the bin buffer 320 earlier are removed first and sent to the bin buffer selector 318.

[0071] Each of the two or more bin buffers 320 is connected to exactly one bin decoder 322, and each bin decoder is connected to only one bin buffer 320. Each bin decoder 322 reads a codeword 323 representing a bit sequence from a separated partial bitstream 324. The bin decoder converts the codeword 323 into a sequence of bins 321 that is sent to the connected bin buffer 320. The overall decoding algorithm converts the two or more partial bitstreams 324 into a number of decoded syntax elements, where the number of partial bitstreams is equal to the number of bin buffers and bin decoders, and the decoding of the syntax elements is triggered by a request for a new syntax element. In a preferred embodiment of the present invention, the bin decoder 322 converts the codeword 323 consisting of a variable number of bits into a sequence of a variable number of bins 321. One advantage of an embodiment of the present invention is that the decoding of bins from two or more partial bitstreams (e.g. for groups with different probability measures) can be performed in parallel, which reduces the processing time for multiple configurations.

[0072] Another advantage of the present invention is that the bin decoding performed by the bin decoder 322 can be specially designed for different sets of parameters 317. In particular, the bin encoding and decoding can be optimized (in terms of coding efficiency and / or complexity) for different groups of estimated probabilities. On the one hand, such optimization can reduce the coding / decoding complexity compared to state-of-the-art entropy coding algorithms with similar coding efficiency. On the other hand, such optimization allows for an increase in coding efficiency compared to state-of-the-art entropy coding algorithms with similar coding / decoding complexity. In a preferred embodiment of the present invention, the bin decoder 322 performs a different decoding algorithm (i.e., a mapping from bin sequence to codewords) for different groups of measures of probability estimates for one of the two possible bin values ​​317 for the current bin request. In a further preferred embodiment of the present invention, the bin decoder 322 performs a different decoding algorithm for different groups of measures of probability estimates for bin values ​​with inferior or superior probabilities for the currently requested bin.

[0073] The bin decoder 322 performs the inverse mapping of the corresponding bin encoder on the encoder side.

[0074] In a preferred embodiment of the present invention, the multiple bin decoder 322 - or one or more bin decoders - represent an entropy decoder that directly maps the codeword 323 to the sequence of bins 321. Such a mapping can be implemented efficiently and does not require a complex arithmetic coding engine. The mapping of the codeword to the sequence of bins needs to be unique. In a preferred embodiment of the present invention, the mapping of the codeword 323 to the sequence of bins 321 is bijective. In a further preferred embodiment of the present invention, the multiple bin decoder 310 - or one or more bin decoders - represent an entropy decoder that directly maps the variable length codeword 323 to the variable length sequence of bins 321. In a preferred embodiment of the present invention, the input codeword represents a redundancy-free code, such as a general Huffman code or a reference Huffman code. Two examples for the bijective mapping of a redundancy-free code to a bin sequence are shown in Table 3.

[0075] In a further preferred embodiment of the present invention, the multiple bin decoder 322 - or one or more bin decoders - represent an entropy decoder that directly maps fixed length codewords 323 to variable length bin sequences 321. In a further preferred embodiment of the present invention, the multiple bin decoder 322 - or one or more bin decoders - represent an entropy decoder that directly maps variable length codewords 323 to fixed length bin sequences 321.

[0076] 7 and 8 thus show an embodiment of an encoder for encoding a sequence of symbols 301 and a decoder for reconstructing it. The encoder comprises an assigner 304 configured to assign several parameters 305 to each symbol of the sequence of symbols based on information contained in the previous symbols of the sequence, such as the category of the syntax element 301, to the representation to which the current symbol belongs, such as a binarization, currently expected according to the syntax structure of the syntax element 301, which can be deduced from the history of the previous syntax elements and the symbols 301. Furthermore, the encoder comprises a number of entropy coders 310, each configured to convert the symbols 301 sent to the respective entropy coder into a respective bitstream 312, and a selector 306 configured to send each symbol 301 to a selected one of the entropy coders 310, the selection being based on the number of parameters 305 assigned to the respective symbol 301. The allocator 304 may also be considered to be integrated with the selector 306 to obtain the respective selector 502 .

[0077] The decoder for reconstructing the symbol sequence comprises a number of entropy decoders 322, each configured to convert a respective bit stream 323 into symbols 321, an assigner 316 configured to assign a number of parameters 317 to each symbol 315 of the symbol sequence to be reconstructed based on information contained in previously reconstructed symbols of the symbol sequence (see 326 and 327 in FIG. 8), and a selector 318 configured to retrieve each symbol of the symbol sequence to be reconstructed from a selected one of the entropy decoders 322, the selection depending on the number of parameters defined for each symbol. The assigner 316 may be configured such that the number of parameters assigned to each symbol includes or is a measure for probability estimation of the distribution between the possible symbol values ​​of each symbol. The assigner 316 and the selector 318 may also be considered to be integrated into one block, namely the selector 402. The sequence of symbols to be reconstructed may be created from a binary alphabet, and the assigner 316 may be configured such that the probability distribution estimate comprises a measure for the probability estimate of a bin value with a less-probable or more-probable probability of two possible bin values ​​of the binary alphabet, and an identifier specifying an estimate of which of the two possible bin values ​​represents the less-probable or more-probable bin value. The assigner 316 may further be configured to internally assign a context to each symbol of the sequence of symbols 315 to be reconstructed based on information contained in a previous reconstructed symbol of the sequence of symbols to be reconstructed, each context with a respective probability distribution estimate associated therewith, and the assigner 316 may further be configured to adapt the probability distribution estimate for each context to the actual symbol statistics based on the symbol values ​​of the previously reconstructed symbols to which the respective context was assigned. This context may take into account the spatial relationship or proximity of the positions to which the syntax elements belong in the video or picture coding, or in a table in the case of financial applications.Then, a measure for the probability distribution estimate for each symbol may be determined based on the probability distribution estimate associated with the context assigned to the respective symbol, for example by quantizing or using the probability distribution estimate associated with the context assigned to the respective symbol (indicated by a pipe index and a refinement index in the following embodiment) as an index into a respective table to one of the representative values ​​of the probability distribution estimates (with the refinement index being separate), thereby obtaining a measure for the probability distribution estimate (with the pipe index pointing to the partial bitstream 312). The selector may be configured to define a bijective association between the entropy coders and the representative values ​​of the probability distribution estimates. The selector 318 may be configured to change the quantization mapping over time from a range of the probability distribution estimates to the representative values ​​of the probability distribution estimates in a predetermined deterministic manner based on previously reconstructed symbols of the symbol sequence. That is, the selector 318 may change the size of the quantization step, i.e. the interval of the probability distribution mapped to the respective probability index, which may be bijectively associated with the respective entropy decoder. The entropy decoders 322 may then be configured to adapt how they convert the symbols into a bitstream in response to changes in the quantization mapping. For example, each entropy decoder 322 may be optimized for a given probability distribution estimate within the quantization interval of the respective probability distribution estimate, i.e. have an optimal compression ratio, and as the entropy decoder 322 is optimized, it may change its mapping of the sequence of codewords / symbols to adapt the position of this given probability distribution estimate within the quantization interval of the respective probability distribution estimate. The selector may be configured to change the quantization mapping such that the rate at which symbols are retrieved from the entropy decoders has less variation. It should be noted that the binarizer 314 may be absent if the syntax element is already binary.Furthermore, depending on the type of decoder 322, the buffer 320 may not be necessary, or the buffer may be integrated within the decoder.

[0078] <end of finite syntax element sequence> In a preferred embodiment of the present invention, encoding and decoding is performed on a finite set of syntax elements. Often, a given amount of data is encoded, such as a still image, a frame or field of a video sequence, a slice of an image, a slice of a frame or field of a video sequence, or a set of consecutive audio samples. For a finite set of syntax elements, it is generally necessary to terminate the partial bitstream created at the encoder side. That is, it must be guaranteed that all syntax elements can be decoded from the transmitted or stored partial bitstream. After the last bin is inserted into the corresponding bin buffer 308, the bin encoder 310 must ensure that a complete codeword is written to the partial bitstream 312. If the bin encoder 310 represents an entropy encoder that directly maps bin sequences to codewords, the bin sequence stored in the bin buffer after writing the last bin to the bin buffer may not represent the bin sequence associated with the codeword (i.e., it may represent a prefix of two or more bin sequences associated with the codeword). In such a case, any codeword associated with a bin sequence that includes the bin sequence as a prefix in the bin buffer needs to be written to the partial bitstream (the bin buffer needs to be flushed). This can be done by inserting bins with specific or arbitrary values ​​into the bin buffer until the codeword is written. In a preferred embodiment of the present invention, the bin encoder selects one of the codewords with the shortest length (in addition to the property that the associated bin sequence must include the bin sequence as a prefix in the bin buffer). On the decoder side, the bin decoder 322 may decode more bins than are required for the last codeword in the partial bitstream, and these bins are not required by the bin buffer selector 318 and are discarded and ignored. The decoding of a finite set of symbols is controlled by the demand for already decoded syntax elements. That is, if no further syntax elements are required for a certain amount of data, the decoding ends.

[0079] <Transmission and multiplexing of partial bitstreams> The partial bitstreams 312 created by the encoder can be transmitted separately or can be multiplexed into a single bitstream, or the codewords of the partial bitstreams can be interleaved into a single bitstream.

[0080] In one embodiment of the present invention, each partial bitstream is written into one data packet, which corresponds to an amount of data, which may be any collection of syntax elements, such as a still image, a field or frame of a video sequence, a slice of a still image, a slice of a field or frame of a video sequence, or a frame of audio samples.

[0081] In another preferred embodiment of the present invention, two or more of the partial bitstreams of an amount of data, or all the partial bitstreams of an amount of data, are multiplexed into one data packet. The structure of a data packet containing the multiplexed partial bitstreams is shown in Figure 9.

[0082] The data packet 400 consists of a header and one partition for each partial bitstream data (for a certain amount of data under consideration). The data packet header 400 contains an indication for partitioning the (remainder of) the data packet into segments 402 of bitstream data. In addition to the indication for the partition, the header may contain further information. In a preferred embodiment of the invention, the indication for the partitioning of the data packet is the start position of the data segment in units of bits or bytes or in units of a number of bits or a number of bytes. In a preferred embodiment of the invention, the start position of the data segment is coded in the header of the data packet as an absolute value, either relative to the start of the data packet or relative to the end of the header or relative to the start of the preceding data packet. In a further preferred embodiment of the invention, the start position of the data segment is coded differentially, i.e. only the difference between the actual start of the data segment and the prediction for the start of the data segment is coded. This prediction can be derived based on already known or transmitted information such as the total size of the data packet, the size of the header, the number of data segments in the data packet, the start position of the preceding data segment, etc. In a preferred embodiment of the invention, the start position of the first data packet is not coded but is inferred based on the size of the header of the data packet. At the decoder side, the transmitted partition indication is used to derive the start of the data segment. The data segment is then used as a partial bitstream, and the data contained in the data segment is fed in order to the corresponding bin decoder.

[0083] There are several options for the method of multiplexing the partial bitstreams into the data packets. One method, which allows reducing the required side information especially if the partial bitstreams are very close in size, is shown in Fig. 10. The payload of the data packet, i.e. the data packet 410 without its header 411, is partitioned into segments 412 in a predefined way. As an example, the payload of the data packet can be partitioned into segments of equal size. Each segment is then associated with a partial bitstream or with the first part of a partial bitstream 413. If a partial bitstream is larger than the associated data segment, its remainder 414 is placed in the unused space at the end of the other data segment. This can be done in such a way that the remainders of the bitstream are inserted in the reverse order (starting from the end of the data segment), reducing the side information. The association of the remainders of the partial bitstream with the data segment and the start point for one or more remainders, in case more than one remainder is added to the data segment, needs to be signaled inside the bitstream, e.g. in the data packet header.

[0084] <Interleaving of variable length codewords> In some applications, the above-mentioned multiplexing of partial bitstreams (related to a certain amount of syntax elements) in one data packet may have the following drawbacks: on the one hand, for small data packets, the number of bits for side information required to signal the partitions may be significant relative to the actual data in the partial bitstream, ultimately reducing the coding efficiency. On the other hand, multiplexing may be unsuitable for applications with low delay requirements (such as video conferencing applications). In the above-mentioned multiplexing, it is not possible for the encoder to start transmitting a data packet before the partial bitstream is completely created, since the start position of the partition is not known in advance. Furthermore, the decoder generally needs to wait until it receives the start of the last data segment before it can start decoding the data packet. In applications such as video conferencing systems, these delays may add up to an additional overall delay in systems with multiple video pictures (especially for bitrates close to the transmission bitrate and for encoders / decoders that require close to the time interval between two pictures to code / decode one picture), which is critical for such applications. To overcome such drawbacks for certain applications, the encoder of a preferred embodiment of the present invention may be configured such that the codewords generated by two or more bin encoders are interleaved into a single bitstream. The bitstream with the interleaved codewords can be sent directly to the decoder (neglecting small buffering delays, see below). At the decoder side, the two or more bin decoders read the codewords directly from the bitstream in decoding order, i.e., decoding can start from the first received bit. Furthermore, no side information is required to signal the multiplexing (or interleaving) of partial bitstreams.A further way to reduce the decoder complexity is obtained if the bin decoder 322 does not read the variable length codewords from the global bit buffer, but instead always reads fixed length bit strings from the global bit buffer and adds these fixed length bit strings to the local bit buffers. Here, each bin decoder 322 is associated with a separate local bit buffer. The variable length codewords are then read from the local bit buffers. This allows the analysis of the variable length codewords to be performed in parallel, and only the access of the fixed length bit strings needs to be performed in a synchronous manner, but such access of the fixed length bit strings is usually very fast, and as a result the overall decoding complexity can be reduced for some architectures. The fixed number of bins sent to a particular local bit buffer may be different for different local bit buffers and may change over time depending on certain parameters as events in the bin decoder, bin buffer, or bit buffer. However, the number of bits read by a particular access does not depend on the actual bits read during a particular access. This is an important difference for reading variable length codewords. The reading of the fixed length bit strings is triggered by certain events in the bin buffers, the bin decoder or the local bit buffer. As an example, it is possible to request the reading of a new fixed length bit string when the number of bits present in the concatenated bit buffers falls below a predefined threshold. In this case, different thresholds can be used for different bit buffers. The encoder needs to ensure that the fixed length bin strings are inserted into the bit stream in the same order as they are read out of the bit stream at the decoder side. It is also possible to combine this fixed length string interleaving with a low latency control similar to that described above. A preferred embodiment for the interleaving of fixed length bit strings is described below. For details on such an interleaving scheme, please refer to US Pat. No. 5,399,633.

[0085] After describing an embodiment in which a previous coding is used to compress the video data, further embodiments for implementing the invention are described which result in a particularly efficient arrangement in terms of the trade-off between compression ratio on the one hand and look-up table and computational overhead on the other hand. In particular, the following embodiment makes it possible to use a computationally less complex variable length code to entropy code the bitstream separately and to efficiently cover part of the probability estimates. In the embodiment described below, the symbols are of a binary nature and the VLC codes described below use R LPS It efficiently covers probability estimation, such as that represented by

[0086] In particular, the following embodiments describe possible implementations of the individual entropy encoder 310 and decoder 322 in Figs. 7-17, respectively. The embodiments are suitable for encoding bins, i.e. binary symbols, as they appear in image or video compression applications. Thus, the embodiments are also applicable to image or video coding, where such binary symbols are split into one or more bin streams 307 to be encoded and one or more bit streams 324 to be decoded, respectively, where each such bin stream can be considered as a realization of a Bernoulli process. The embodiments described below encode the bin streams using various so-called variable / variable codes (v2v codes), which are described below. A v2v code may be considered as two prefixless codes with the same number of codewords, i.e. a first-order and a second-order prefixless code. Each codeword of the first-order prefixless code is associated with one codeword of the second-order prefixless code. According to the embodiment described below, at least some of the encoders 310 and decoders 322 operate as follows: whenever a codeword of the primary no-prefix code is read from the buffer 308 to encode a particular bin sequence 307, a corresponding codeword of the secondary no-prefix code is written to the bitstream 312. A similar process is used to decode such a bitstream 324, except that the primary and secondary no-prefix codes are swapped: whenever a codeword of the secondary no-prefix code is read from the respective bitstream 324 to decode the bitstream 324, a corresponding codeword of the primary no-prefix code is written to the buffer 320.

[0087] Advantageously, the codes described below do not require look-up tables. They can be constructed in the form of finite state machines. The v2v codes described here can be generated by simple construction rules, so there is no need to store large tables for the codewords. Instead, simple algorithms can be used to perform the encoding and decoding. Three construction rules are described below, two of which can be parameterized. They cover different or even disjoint parts of the probability intervals mentioned above, so it is particularly advantageous to use, for example, all three codes (each in parallel for a different one of the encoders 310 / decoders 322) or to use two of them. Using the construction rules described below, it is possible to design a set of v2v codes such that in a Bernoulli process with any probability p, one of the codes works well for excessive code lengths.

[0088] As mentioned above, the encoding and decoding of the streams 312 and 324 may be performed independently for each stream or in an interleaved manner. However, this is not specific to the class of v2v codes described herein. Therefore, in the following description, only the encoding and decoding of specific codewords for each of the three construction rules is described. However, it is emphasized that all of the above-mentioned embodiments related to the interleaving solutions can also be combined for the codes described herein, or for the encoder 310 and the decoder 322, respectively.

[0089] Construction rule 1: "UNALIVINE PIPE" code or encoder 310 / decoder 322 The unary bin PIPE code (PIPE = probability interval partitioning entropy) is a special version of the so-called "bin PIPE" code, i.e. a code suitable for encoding either of the individual bit streams 312 and 324 carrying data of binary symbol statistics each belonging to a subinterval of a given probability of the probability range [0; 0.5] mentioned above. First, the construction of the bin PIPE code is described. The bin PIPE code can be constructed from any prefix-free code with at least three codewords. To form one v2v code, the bin PIPE code uses prefix-free codes as the primary and secondary codes, but the two codewords of the secondary prefix-free code are swapped. This means that the bins are written unchanged in the bit stream, except for the two codewords. This technique reduces memory consumption, since only one prefix-free code needs to be stored with the information, and two codewords are swapped. It should be noted that it makes sense to swap codewords of different lengths. Otherwise the bitstream would end up having the same length as the bin stream (without taking into account effects that occur at the end of the bin stream).

[0090] With this construction rule, a notable property of bin-PIPE codes is that if the primary and secondary prefixless codes are swapped (while the codeword mappings are preserved), the resulting v2v code is identical to the original v2v code. Hence, the encoding and decoding algorithms are identical for bin-PIPE codes.

[0091] Unarybin PIPE codes are constructed from special prefix-less codes. The special prefix-less codes are constructed as follows: First, a prefix-less code consisting of n unary codewords is generated starting with '01', '001', '0001' until n codewords are generated, where n is the parameter of the unarybin PIPE code. From the longest codeword, trailing 1s are removed. This corresponds to a truncated unary code (but without the codeword '0'). Next, n-1 unary codewords are generated starting with '10', '110', '1110' until n-1 codewords are generated. From the longest codeword, trailing 0s are removed. The union of these two prefix-less codes is used as input to generate the unarybin PIPE code. The two codewords that are swapped are a codeword consisting of all 0s and a codeword consisting of all 1s.

[0092] Example for n=4: Number 1st 2nd 1 0000 111 2 0001 0001 3 001 001 4 01 01 5 10 10 6 110 110 7 111 0000

[0093] Construction rule 2: "Unary-to-Rice" code and unary-to-rice encoder 10 / decoder 22: The unary-to-rice code uses truncated unary codes as the primary codes. That is, the unary code words start with '1', '01', '001', and so on. n+1 codewords are generated and trailing ones are removed from the longest codeword, where n is the parameter of the unary-to-rice code. A second-order prefixless code is constructed from the codewords of a first-order prefixless code as follows: For a first-order codeword that consists entirely of zeros, the codeword '1' is assigned. All other codewords consist of the concatenation of the codeword '0' with the n-bit binary representation of the number of zeros in the corresponding codeword of the first-order prefixless code.

[0094] Example for n=3: Number 1st 2nd 1 1 0000 2 01 0001 3 001 0010 4 0001 0011 5 00001 0100 6 000001 0101 7 0000001 0110 8 00000001 0111 9 00000000 1 This is an infinite unary code with Rice parameter 2 n Note that this is equivalent to mapping to a Rice code with

[0095] Construction rule 3: "Three bin" code The three bin codes are given as follows: Number 1st 2nd 1 000 0 2 001 100 3 010 101 4 100 110 5 110 11100 6 101 11101 7 011 11110 8 111 11111

[0096] It has the property that the first-order code (symbol sequence) is of fixed length (always three bins) and the codewords are sorted in ascending order of the number of 1s.

[0097] An example of an efficient construction of a three bin code is given below. The encoder and decoder for this three bin code can be constructed as follows, without storing tables.

[0098] At the encoder (any of 10), three bins are read from the bin stream (i.e., 7). If these three bins contain exactly one 1, then the codeword '1' is written into the bitstream, followed by two bins consisting of the binary representation of the 1's position (starting from the right with 00). If the three bins contain exactly one 0, then the codeword '111' is written into the bitstream, followed by two bins consisting of the binary representation of the 0's position (starting from the right with 00). The remaining codewords '000' and '111' are mapped to '0' and '11111', respectively.

[0099] At the decoder (any of 22), one bin or bit is read from the respective bit stream 24. If one bin or bit is equal to '0', then the code word '000' is decoded into the bin stream 21. If it is equal to '1', then two more bins are read from the bit stream 24. If these two bits are not equal to '11', then these bits are interpreted as a binary representation of a number, and two 0's and one 1 are decoded from the bit stream, with the position of the 1 being determined by the number. If the two bits are equal to '11', then two more bits are interpreted as a binary representation of a number. If the number is less than 3, then two 1's and one 0 are decoded, and this number determines the position of the 0. If it is equal to 3, then '111' is decoded into the bin stream.

[0100] An example of an efficient construction of the unary bin PIPE code is described below. The encoder and decoder for the unary bin PIPE code can be implemented efficiently using counters. Due to the structure of the bin PIPE code, encoding and decoding of the bin PIPE code is easy to implement.

[0101] In an encoder (any of 10), if the first bin of a codeword is equal to '0', the bin is processed until either a '1' is encountered or n 0's have been read (including the first '0' of the codeword). If a '1' is encountered, the bin read is written unchanged to the bitstream. Otherwise (i.e., n 0's have been read), n-1 1's are written to the bitstream. If the first bin of a codeword is equal to '1', the bin is processed until either a '0' is encountered or n-1 1's have been read (including the first '1' of the codeword). If a '0' is encountered, the bin read is written unchanged to the bitstream. Otherwise (i.e., n-1 1's have been read), n 0's are written to the bitstream.

[0102] In the decoder (any of 322), the same algorithm is used as for the encoder, since it is the same for the bin PIPE code as described above.

[0103] An efficient construction of a unary-to-rice code is described below. Encoders and decoders for unary-to-rice codes can be implemented efficiently using counters as described here.

[0104] In the encoder (any of 310), a bin is either a 1 or a 2. n The bin stream is read until 0s are read (i.e. 7). The number of 0s is counted. When the count is 2 n If so, then the codeword '1' is written to the bitstream, otherwise a '0' is written followed by the binary representation of the counted number in n bits.

[0105] In the decoder (one of 322), one bit is read. If this bit is equal to '1', then 2 nn zeros are decoded into a bin string. If this bit is equal to '0' then n further bits are read and interpreted as a binary representation of a number. This number of zeros is decoded into a bin stream followed by one '1'.

[0106] In other words, the embodiment just described describes an encoder for encoding a sequence of symbols 303 comprising an assigner 316 configured to assign a number of parameters 305 to each symbol of the sequence based on information contained in previous symbols of the sequence, a number of entropy encoders 310 each configured to convert the symbols 307 transmitted to a respective entropy encoder 310 into a respective bitstream 312, and a selector 6 configured to transmit each symbol 303 to a selected one of the multiple entropy encoders 310, the selection being dependent on the number of parameters 305 assigned to the respective symbol 303. According to this embodiment, at least a first subset of the entropy coders may be variable length coders configured to respectively map variable length symbol sequences in the stream of symbols 307 to variable length code words to be inserted in the bit stream 312, where each of the entropy coders 310 of the first subset uses a bijective mapping rule based on which a code word of a first-order prefix-free code having (2n-1)≧3 code words is mapped to a code word of a second-order prefix-free code that is identical to the first-order prefix code, such that all but two of the code words of the first-order prefix-free code are mapped to identical code words of the second-order prefix-free code, while the two code words of the first and second-order prefix-free codes have different lengths and are mapped interchangeably, where different n may be used between the entropy coders to cover different parts of the interval of the above-mentioned probability interval. The first prefix-free code is a codeword of the first prefix-free code (a,b)2, (a,a,b)3, ..., (a,...,a,b). n ,(a,...,a) n,(b,a)2,(b,b,a)3,...,(b,...,b,a) n-1 ,(b,...,b) n-1 The two codewords mapped to the interchangeable states are (a,...,a) n and (b,...,b) n-1 and where b ≠ a and a, b ∈ {0,1}. However, alternative methods are also feasible.

[0107] In other words, each of the first subset of entropy encoders examines a first symbol transmitted to its respective entropy encoder when converting the symbols transmitted to its respective entropy encoder into a respective bit stream; (1) Determine whether the first symbol is equal to a ∈ {0,1}, and if so, each entropy encoder examines subsequent symbols transmitted to the respective entropy encoder; (1.1) determining whether b, where b ≠ a and b ∈ {0,1}, occurs within the next n-1 symbols following the initial symbol, and if so, each entropy encoder is configured to write a codeword into each bit stream equal to the initial symbol followed by subsequent symbols transmitted to each entropy encoder, up to symbol b; (1.2) Determine whether b does not occur at all in the next n-1 symbols following the first symbol, and if so, each entropy encoder decodes (b,...,b) n-1 or (2) determining whether the first symbol is equal to b, and if so, each entropy encoder examines subsequent symbols transmitted to the respective entropy encoder; (2.1) determining whether a occurs within the next n-2 symbols following the initial symbol, and if so, each entropy encoder is configured to write a codeword into each bit stream equal to the initial symbol followed by subsequent symbols transmitted to each entropy encoder, up to symbol a; or (2.2) Determine whether a does not occur at all in the next n-2 symbols following the first symbol, and if so, each entropy encoder decodes (a,...,a) n The method is configured to write a codeword into each bitstream equal to

[0108] Additionally or alternatively, the second subset of entropy encoders 10 may be variable length encoders configured to respectively map variable length symbol sequences to fixed length codewords, where each of the entropy encoders in the second subset uses a bijective mapping rule to map two-dimensional codewords of type {(a),(ba),(bba),...,(b...ba),(bb...b)}, where b≠a and a,b∈{0,1}, based on the bijective mapping rule. n A codeword of a first-order truncated unary code having +1 codewords is mapped to a codeword of a second-order prefix-less code such that a codeword of a first-order truncated unary code (bb...b) is mapped to a codeword of a second-order prefix-less code (c) and all other codewords {(a),(ba),(bba),...,(b...ba)} of the first-order truncated unary code are mapped to codewords having (d) as a prefix and an n-bit word as a suffix, with c≠d and c,d∈{0,1}, where each entropy coder uses a different n. Each of the second subset of entropy coders may be configured such that the n-bit word is an n-bit representation of the number b in the respective codeword of the first-order truncated unary code. However, alternative methods are also feasible.

[0109] Again, from the viewpoint of the operation mode of each of the encoders 10, each of the second subset of entropy encoders converts the symbols transmitted to the respective entropy encoders into the respective bit streams until a occurs or the number of symbol sequences transmitted to the respective entropy encoders becomes 2 n 2 in a row n 2 such that all symbols are b n and counting the number of b in the symbol sequence transmitted to each entropy encoder until (1) The number of b's is 2 n If so, write c, where c∈{0,1}, into each bitstream as a codeword of the second-order prefix-free code; (2) The number of b's is 2 n If it is smaller, write the codeword of the second-order prefix-free code into each bit stream having (d) as a prefix, where c ≠ d and d ∈ {0,1}, and an n-bit word determined by the number b as a suffix.

[0110] Additionally or alternatively, a given one of the entropy encoders 10 may be a variable length encoder configured to map fixed length symbol sequences to variable length codewords, respectively, using a bijective mapping rule, and based on the bijective mapping rule, a first order codeword having length 3 may be generated by the given entropy encoder. 3codewords are mapped to codewords of a secondary prefix-less code, so that a codeword (aaa)3 of the primary code with a∈{0,1} is mapped to a codeword (c) with c∈{0,1}, all three codewords of the primary code with only one b, with b≠a and b∈{0,1}, are mapped to a codeword having (d) with c≠d and d∈{0,1} as a prefix and a respective first 2-bit word from a first set of 2-bit words as a suffix, and all three codewords of the primary code with only one a are mapped to a codeword having (d) as a prefix and a concatenation of the first 2-bit word that is not an element of the first set and a second 2-bit word from a second set of 2-bit words as a suffix. The codeword (bbb)3 is mapped to a codeword having (d) as a prefix and a concatenation of a first 2-bit word that is not an element of the first set and a second 2-bit word that is not an element of the second set as a suffix. The first 2-bit word of the codeword of the primary code with only one b may be a 2-bit representation of the position of b in each codeword of the primary code, and the second 2-bit word of the codeword of the primary code with only one a may be a 2-bit representation of the position of a in each codeword of the primary code. However, alternative methods are also feasible.

[0111] Again, a given one of the entropy coders may be configured, when converting the symbols transmitted to the given entropy coder into a respective bit stream, to check the symbols in a triplet to the given entropy coder for: (1) checking whether the triplet consists of multiple a's, and if so, a given entropy coder is configured to write a codeword (c) into the respective bitstream; (2) checking whether the triplet contains exactly one b, and if so, a given entropy coder is configured to write into each bitstream a codeword having (d) as a prefix and a two-bit representation of the position of b in the triplet as a suffix; (3) checking whether the triplet contains exactly one a, and if so, the given entropy coder is configured to write into the respective bitstream a codeword having (d) as a prefix and having as a suffix the concatenation of a first 2-bit word that is not an element of the first set and a 2-bit representation of the position of a in the triplet; or (4) It may be checked whether the triplet consists of multiple b's, and if so, the given entropy encoder may be configured to write into the respective bitstream a codeword having (d) as a prefix and having as a suffix the concatenation of a first 2-bit word that is not an element of the first set and a first 2-bit word that is not an element of the second set.

[0112] Regarding the decoding side, the embodiment just described discloses a decoder for reconstructing a sequence of symbols 326, comprising a number of entropy decoders 322, each configured to convert a respective bit stream 324 into symbols 321, an assignment unit 316 configured to assign several parameters to each symbol 326 of the symbol sequence to be reconstructed based on information contained in previously reconstructed symbols of the symbol sequence, and a selection unit 318 configured to retrieve each symbol 325 of the symbol sequence to be reconstructed from a selected one of the multiple entropy decoders, the selection depending on the number of parameters defined for the respective symbol. According to this embodiment, at least a first subset of the entropy decoders 322 are variable length decoders configured to respectively map variable length codewords to variable length symbol sequences, where each of the entropy decoders 322 of the first subset uses a bijective mapping rule based on which a codeword of a first-order prefix-free code having (2n-1)≧3 codewords is mapped to a codeword of a second-order prefix-free code that is identical to the first-order prefix code, such that all but two of the codewords of the first-order prefix-free code are mapped to identical codewords of the second-order prefix-free code, while the two codewords of the first and second-order prefix-free codes have different lengths and are mapped interchangeably, where each entropy decoder uses a different n. The first prefix-free code is a codeword of the first prefix-free code (a,b)2, (a,a,b)3, ..., (a,...,a,b). n ,(a,...,a) n ,(b,a)2,(b,b,a)3,...,(b,...,b,a) n-1 ,(b,...,b) n-1 and two codewords mapped with each other in a permuted manner are (a,...,a) n and (b,...,b) n-1 where b ≠ a and a, b ∈ {0,1}. However, alternative methods are also feasible.

[0113] Each of the first subset of entropy decoders may be configured, in converting the respective bit streams into symbols, to check a first bit of the respective bit stream for: (1) determining whether a first bit is equal to a∈{0,1}, and if so, each entropy decoder is configured to examine subsequent bits of each bitstream; (1.1) determining whether b occurs within the next n-1 bits following the first bit, with b ≠ a and b ∈ {0,1}, and if so, each entropy decoder is configured to reconstruct a sequence of symbols equivalent to the first bit followed by subsequent bits of the respective bit stream up to bit b, or (1.2) Determine whether b does not occur at all in the next n-1 bits following the first bit, and if so, each entropy decoder decodes (b,...,b). n-1 or (2) determining whether the first bit is equal to b, and if so, each entropy decoder is configured to examine subsequent bits of each bitstream; (2.1) determining whether a occurs within the next n-2 bits following the first bit, and if so, each entropy decoder is configured to reconstruct a sequence of symbols equivalent to the first bit followed by subsequent bits of the respective bit stream up to the symbol a, or (2.2) Determine whether a does not occur at all within the next n-2 bits following the first bit, and if so, each entropy decoder decodes (a,...,a) n The method may be configured to reconstruct a sequence of symbols equal to

[0114] Additionally or alternatively, at least a second subset of the entropy decoders 322 may be variable length decoders configured to respectively map fixed length codewords to variable length symbol sequences, where each of the entropy decoders of the second subset uses a bijective mapping rule based on which the codewords of the second order prefix-free code are transformed into a first order prefix-free code having 2n+1 codewords of type {(a),(ba),(bba),...,(b...ba),(bb...b)}, where b≠a and a,b∈{0,1}. , b, d, . . . , 0, 1}, such that codeword (c) of the second-order prefix-free code is mapped to codewords (bb...b) of the first-order truncated unary code, and each codeword having (d) as a prefix and an n-bit word as a suffix, with c≠d and c,d∈{0,1}, is mapped to a respective one of the other codewords {(a),(ba),(bba),...,(b...ba)} of the first-order truncated unary code, where each entropy decoder uses a different n. Each of the second subset of entropy decoders may be configured such that the n-bit word is an n-bit representation of the number b in the respective codeword of the first-order truncated unary code. However, alternative methods are also feasible.

[0115] Each of the second subset of entropy decoders may be a variable length decoder configured to map a respective fixed length codeword into a respective variable length sequence of symbols, and may be configured to, in converting the respective entropy decoder bit streams into symbols, check a first bit of each respective bit stream for: (1) Determine whether the first bit is equal to c, where c ∈ {0,1}. If so, then each entropy decoder is equal to (bb...b), where b ∈ {0,1}. n or (2) Determine whether the first bit is equal to d, c≠d and c,d∈{0,1}, and if so, each entropy decoder may be configured to determine an n-bit word from n further bits of the respective bit stream following the first bit, and to reconstruct from the n-bit word a sequence of symbols of type {(a),(ba),(bba),...,(b...ba),(bb...b)}, where b≠a and b∈{0,1}, and the number of b depends on the n-bit word.

[0116] Additionally or alternatively, a given one of the entropy decoders 22 may be a variable length decoder configured to map the variable length codewords to fixed length symbol sequences, respectively, using a bijective mapping rule, based on which the codewords of the second-order prefix-less code are 2 times the length of the first-order code. 3so that codeword (c), where c∈{0,1}, is mapped to codeword (aaa)3 of the primary code, where a∈{0,1}, and a codeword having (d), where c≠d and d∈{0,1}, as a prefix and a respective first 2-bit word from a first set of three 2-bit words as a suffix is ​​mapped to all three codewords of the primary code with exactly one b, where b≠a and b∈{0,1}, and A codeword having as a suffix a concatenation of a first 2-bit word that is not an element of the first set and a second 2-bit word from a second set of three 2-bit words, with (d) as a prefix, and a codeword having as a suffix a concatenation of a first 2-bit word that is not an element of the first set and a second 2-bit word that is not an element of the second set, is mapped to all three codewords of the primary code with exactly one a, and a codeword having as a prefix (d) and a suffix a concatenation of a first 2-bit word that is not an element of the first set and a second 2-bit word that is not an element of the second set is mapped to the codeword (bbb)3. The first 2-bit word of the codeword of the primary code with exactly one b may be a 2-bit representation of the position of b in the respective codeword of the primary code, and the second 2-bit word of the codeword of the primary code with exactly one a may be a 2-bit representation of the position of a in the respective codeword of the primary code. However, alternative methods are also feasible.

[0117] A given one of the entropy decoders may be a variable length decoder configured to map the variable length codewords into respective symbol strings of three symbols each, and may be configured to, in converting the respective entropy decoder bit streams into symbols, check a first bit of each bit stream for: (1) determining whether the first bit of each bitstream is equal to c, c∈{0,1}, and if so, a given entropy decoder is configured to reconstruct a sequence of symbols equal to (aaa)3, a∈{0,1}; or (2) determining whether the first bit of each bit stream is equal to d, where c≠d and d∈{0,1}, and if so, the given entropy decoder is configured to determine a first 2-bit word from two further bits following the first bit of each bit stream, and further inspecting the first 2-bit word to: (2.1) determining whether the first 2-bit word is not an element of a first set of three 2-bit words, and if so, the given entropy decoder is configured to reconstruct a sequence of symbols having exactly one b, with b ≠ a and b ∈ {0,1}, where the position of b in the respective sequence of symbols depends on the first 2-bit word, or (2.2) determining whether a first 2-bit word is an element of a first set, and if so, a given entropy decoder is configured to determine a second 2-bit word from two further bits of the respective bit stream following the two bits from which the first 2-bit word was determined, and further configured to examine the second 2-bit word, (3.1) determining whether the second 2-bit word is not an element of a second set of three 2-bit words, and if so, the given entropy decoder is configured to reconstruct a sequence of symbols having only one a, where the position of a in each symbol sequence depends on the second 2-bit word, or (3.2) determining whether the second 2-bit word is an element of a second set of three 2-bit words, and if so, the given entropy decoder may be configured to reconstruct a sequence of symbols equal to (bbb)3.

[0118] After describing the overall concept of the video coding scheme, the embodiments of the present invention will be described with reference to the above-mentioned embodiments, in other words, the embodiments described below may be implemented using the above-mentioned scheme, and conversely, the embodiments described below may be used and developed to implement the above-mentioned coding scheme.

[0119] In the above-mentioned embodiment described in relation to Figs. 7-9, the entropy encoder and decoder of Figs. 1-6 were constructed according to the PIPE concept. In one particular embodiment, an arithmetic single probability state encoder 310 / decoder 322 was used. As will be explained below, according to other embodiments, the entities 306-310 and the corresponding entities 318-322 may be replaced by a conventional entropy coding engine. For example, an arithmetic coding engine may process only one common state R and L and code all symbols into one common bit stream, thus giving up the advantageous aspects of the current PIPE concept regarding parallel processing, while eliminating the need to interleave partial bit streams, as will be explained below. In that way, the number of probability states on the basis of which the context probability is estimated by the update (table lookup) may be larger than the number of probability states on the basis of which the subdivision of the probability interval is performed. That is, similar to the quantization of the value of the probability interval width before indexing into the table Rtab, the probability state index may also be quantized. Therefore, the above-mentioned possible configurations of the single encoder 310 and decoder 322 can be expanded as examples of the configurations of the entropy encoders / decoders 318-322 / 306-310 as engines of context-adaptive binary arithmetic encoding / decoding.

[0120] More specifically, according to one embodiment, the output of the parameter assigner (now acting as a context assigner) may operate as follows: 0. The assigner 304 transmits the bin value along with the probability parameter: Probability is pState_current[bin]. 1. Thus, the entropy coding engine receives 1) valLPS, 2) bins, and 3) a probability distribution estimate pState_current[bin]. pState_current[bin] may have a larger number of states than the number of distinct probability state indexes in Rtab. In that case, pState_current[bin] may be quantized, for example by ignoring m LSBs, where m is 1 or more, possibly 2 or 3, to obtain one p_state, i.e. the index used to access the table Rtab next. However, this quantization does not have to be done. That is, p_state may be pState_current[bin]. 2. Quantization of R is then performed (as described above, either one R (and corresponding L with one common bitstream) is used / processed for all distinct values ​​of p_state, or one R (and corresponding L with associated partial bitstreams for each R / L pair) is used / processed for each distinct value of p_state, which in the latter case would be equivalent to having one bin encoder 310 for each such value). q_index = Qtab[R>>q] (or other form of quantization) 3. Next, R LPS and the decision of R is executed. R LPS =Rtab[p_state][q_index]; Rtab has pre-computed values ​​for p[p_state]·Q[q_index] stored in it. R=RR LPS (i.e. R is pre-updated as if "bin" were MPS) 4. Calculate the new subinterval: If (bin = 1 - valMPS), L￢L+R R￢R LPS 5. Renormalize L and R, writing bits.

[0121] Similarly, an entropy decoder connected to the output of a parameter allocator (now acting as a context allocator) may operate as follows: 0. The assigner 304 transmits the bin value along with the probability parameter: Probability is pState_current[bin]. 1. Thus, the entropy decoding engine receives a request for a bin together with 1) valLPS and 2) a probability distribution estimate pState_current[bin]. pState_current[bin] may have a larger number of states than the number of distinct probability state indexes in Rtab. In that case, pState_current[bin] may be quantized, for example by ignoring m LSBs, where m is 1 or more, possibly 2 or 3, to obtain one p_state, i.e. the index used to access the table Rtab next. However, this quantization does not have to be done. That is, p_state may be pState_current[bin]. 2. Quantization of R is then performed (as described above, either one R (and corresponding V with one common bitstream) is used / processed for all distinct values ​​of p_state, or one R (and corresponding V with associated partial bitstreams for each R / L pair) is used / processed for each distinct value of p_state, which in the latter case would be equivalent to having one bin encoder 310 for each such value). q_index = Qtab[R>>q] (or other form of quantization) 3. Next, R LPS and the decision of R is executed. R LPS =Rtab[p_state][q_index]; Rtab has pre-computed values ​​for p[p_state]·Q[q_index] stored in it. R=RR LPS (i.e. R is pre-updated as if "bin" were MPS) 4. Determining bins based on subinterval locations: (V 3 In the case of R), bin ¬ 1-valMPS (The bin is decoded as LPS. The bin buffer selector 18 uses this bin information and valMPS to get the actual bin value.) V￢VR R￢R LPS At other times, bin → valMPS (The bin is decoded as MPS. This bin information and valMPS are used to get the actual bin value.) 5. Renormalize R, read 1 bit and update V.

[0122] As mentioned above, the allocator 4 allocates pState_current[bin] for each bin. The association may be performed based on a context selection, i.e. the allocator 4 may select a context using a context index ctxIdx, with which the respective pState_current is associated. A probability update may be performed each time the probability pState_current[bin] is applied to the current bin. The update of the probability state pState_current[bin] is performed based on the value of the coded bit. If (bit = 1 - valMPS), pState_current ← Next_State_LPS [pState_current] If (pState_current = 0), valMPS ← 1-valMPS Other cases pState_current ← Next_State_MPS [pState_current]

[0123] If more than one context is given, the adaptation is performed per context, i.e. pState_current[ctxIdx] is used for encoding and then updated with the current bin value (encoded or decoded, respectively).

[0124] As will be described in more detail below, according to the following embodiments, the encoder and decoder may be optionally configured to operate in different modes, namely low complexity (LC) and high efficiency (HE) modes. This is described below mainly with respect to PIPE encoding (and mentioning LC and HE-PIPE modes). However, the details of the complexity scalability described can be easily transferred to other configurations of the entropy encoding / decoding engine, such as the embodiment using one common context-adaptive arithmetic encoder / decoder.

[0125] According to the embodiment described below, both entropy coding modes can share the following: - Identical syntax and semantics (for syntax element sequences 301 and 327, respectively) The same binarization scheme for all syntax elements (as currently specified for CABAC) (i.e. the binarizer may operate regardless of the active mode) Use of the same PIPE code (i.e. the bin encoder / decoder may operate regardless of the active mode) · Use of an 8-bit probability model initialization value (instead of a 16-bit initialization value as currently specified for CABAC).

[0126] Generally speaking, the LC-PIPE and the HE-PIPE differ in processing complexity, such as the complexity of selecting a PIPE path 312 for each bin.

[0127] For example, the LC mode may operate under the following restrictions: there may be only one probability model, i.e., one ctxIdx, for each bin (binIdx). That is, no context selection / adaptation may be provided in the LCPIPE. However, certain syntax elements, such as those used for residual coding, may be coded using context, as further described below. Furthermore, all probability models may be non-adaptive. That is, all models may be initialized at the beginning of each slice with appropriate model probabilities (depending on the selection of slice type and slice QP) and may be fixed throughout the processing of that slice. For example, only eight different model probabilities corresponding to eight different PIPE codes 310 / 322 may be supported for both context modeling and coding. Specific syntax elements for residual coding, i.e., significance_coeff_flag and coeff_abs_level_greaterX (where X=1,2), whose semantics are explained in more detail below, may be assigned to probability models such that (at least) groups of, for example, four syntax elements, are coded / decoded with the same model probabilities. Compared to CABAC, the LC-PIPE mode can achieve roughly the same RD performance and the same processing power.

[0128] HE-PIPE may be conceptually similar to CABAC in H.264, with the following differences: Binary Arithmetic Coding (BAC) is replaced by PIPE coding (as in LC-PIPE). Each probability model, i.e., each ctxIdx, may be represented by a pipeIdx and a refineIdx, where pipeIdx, with values ​​in the range 0...7, represents the model probabilities of 8 different PIPE codes. This change only affects the internal representation of the states, and does not affect the behavior of the state machine (i.e., probability estimation). As described in more detail below, the initialization of the probability model may use an 8-bit initialization value as described above. The backward scanning of the syntax elements coeff_abs_level_greaterX (where X=1,2), coeff_abs_level_minus3, and coeff_sign_flag (whose semantics will become clear from the following description) may be performed in the same scanning path as the forward scan (used, for example, in the encoding of the significance map). The derivation of the context for encoding coeff_abs_level_greaterX, where X=1,2, may also be simplified.Compared to CABAC, the proposed HE-PIPE can achieve roughly similar RD performance with better throughput.

[0129] For example, it is easy to understand that the modes mentioned immediately above can be easily formed by rendering the context-adaptive binary arithmetic encoding / decoding engine mentioned immediately above to operate in various modes.

[0130] Thus, according to an embodiment of the first aspect of the invention, a decoder for decoding a data stream may be constructed as shown in Fig. 11. The decoder is for decoding a data stream 401, such as the interleaved bitstream 340, in which media data, such as video data, have been encoded. The decoder comprises a mode switch 400, configured to activate a low complexity mode or a high efficiency mode depending on the data stream 401. For this purpose, the data stream 401 may comprise a syntax element, such as a binary syntax element, having a binary value 1, in which the low complexity mode is the mode to be activated, and a binary value 0, in which the high efficiency mode is the mode to be activated. Obviously, the relationship between the binary value and the encoding mode can be switched, and also non-binary syntax elements with more than two possible values ​​can be used. Since the actual choice between both modes is still unknown prior to receipt of the respective syntax element, this syntax element may be included within some leading header of the data stream 401, for example coded using fixed probability estimates or models, or may be written into the data stream 401 as is, i.e. using the bypass mode.

[0131] Furthermore, the decoder of Fig. 11 may include several entropy decoders 322, each of which is arranged to convert a codeword in the data stream 401 into a partial sequence of symbols 321. As mentioned above, a deinterleaver 404 may be connected between the input of the entropy decoder 322 on the one hand and the input of the decoder of Fig. 11 to which the data stream 401 is applied on the other hand. Furthermore, as already mentioned above, each of the entropy decoders 322 may be associated with a respective probability interval, in which case each probability interval of the different entropy decoders may together cover a global probability interval from 0 to 1 (or from 0 to 0.5, in case the entropy decoders 322 deal with MPS and LPS instead of absolute symbol values). More details on this point have been given above. In the following, it is assumed that the number of decoders is eight, each of which is assigned one PIPE index, but any other number is also possible. Furthermore, one of these coders, exemplarily with pipe_id 0 in the following, is optimized for bins with equi-probable statistics, i.e. those bin values ​​that assume 1 and 0 are equally likely. The decoder may simply pass the bin on to the next. Each of the coders 310 works in a similar way. There may be no bin manipulation by the selectors 402 and 502, respectively, depending on the value of the bin value with the highest probability, i.e. valMps. In other words, the entropy of each partial stream is already optimal.

[0132] 11 further includes a selection unit 402 configured to retrieve each symbol of the symbol sequence 326 from a selected one of the entropy decoders 322. As mentioned above, the selection unit 402 may be decomposed into a parameter assignment unit 316 and a selection unit 318. The desymbolizer 314 is configured to desymbolize the symbol sequence 326 to obtain a syntax element sequence 327. The reconstructor 404 is configured to reconstruct the media data 405 based on the syntax element sequence 327. The selection unit 402 is configured to perform the selection depending on an activated one of a low complexity mode and a high efficiency mode, as indicated by an arrow 406.

[0133] As already mentioned above, the reconstructor 404 may be part of a predictive block-based video decoder operating on a fixed syntax and semantics of syntax elements, i.e. fixed with respect to the mode selection by the mode switch 400. That is to say, the construction of the reconstructor 404 is not affected by the mode switchability. More precisely, the reconstructor 404 does not increase the implementation overhead due to the mode switchability brought about by the mode switch 400, and furthermore, the functionality at least with respect to the residual data and the prediction data is the same regardless of the mode selected by the switch 400. The same is true with respect to the entropy decoders 322. All these entropy decoders 322 are reused in both modes. Thus, the decoder of FIG. 11 is compatible with both modes, i.e. low complexity mode and high efficiency mode, but without additional implementation overhead.

[0134] An aspect feature to note is that the decoder of Figure 11 is not only capable of operating on a self-contained data stream in one mode or the other, but rather the data stream 401 and decoder of Figure 11 may be configured to even be able to switch between both modes during one piece of media data, such as in the middle of a video or some audio piece, thereby controlling the encoding complexity on the decoding side using a feedback channel from the decoder to the encoder, for example depending on battery status or other external or environmental conditions, thereby providing context-locked-loop control of the mode selection.

[0135] Therefore, the decoder of Fig. 11 works in the same way in both cases, i.e. when LC mode and when HE mode are selected. The reconstructor 404 performs reconstruction using syntax elements and requests current syntax elements of a given syntax element type by processing or following a syntax structure prescription. The desymbolizer 314 requests several bins to provide a valid binarization for the syntax element requested by the reconstructor 404. Obviously, in the case of a binary alphabet, the binarization performed by the desymbolizer 314 simply sends the respective bin / symbol 326 to the reconstructor 404 as the currently requested binary syntax.

[0136] However, the selector 402 operates independently of the mode selected by the mode switch 400. The operation mode of the selector 402 tends to be more complex in the high efficiency mode and less complex in the low complexity mode. Furthermore, as will be seen from the following description, the operation mode of the selector 402 in the low complexity mode also tends to reduce the rate at which the selector 402 changes the selection between the entropy decoders 322 when retrieving consecutive symbols from the entropy decoders 322. In other words, in the low complexity mode, directly consecutive symbols are more likely to be retrieved from the same entropy decoder among the multiple entropy decoders 322. This allows for faster retrieval of symbols from the entropy decoders 322. On the other hand, in the high efficiency mode, the operation mode of the selector 402 tends to guide the selection between the entropy decoders 322 as follows: That is, a selection such that the probability interval associated with each selected entropy decoder 322 corresponds more closely to the actual symbol statistics of the symbols currently being retrieved by the selector 402, and thus results in a better compression ratio on the encoding side when generating each data stream according to the high efficiency mode.

[0137] For example, different behaviors of the selector 402 in both modes may be realized as follows: For example, for a given symbol, the selector 402 may select between the entropy decoders 322 depending on previously retrieved symbols of the symbol sequence 326 when the high efficiency mode is activated, and independently of previously retrieved symbols of the symbol sequence when the low complexity mode is activated. The dependency on previously retrieved symbols of the symbol sequence 326 may be based on context adaptivity and / or probability adaptivity. Both adaptivities may be switched off during the low complexity mode in the selector 402.

[0138] According to further embodiments, the data stream 401 may be a structure with consecutive parts, such as slices, frames, groups of pictures, sequences of frames or others, and each symbol of a symbol sequence may be associated with a respective one of a number of symbol types. In this case, the selector 402 may be configured to vary its selection for symbols of a given symbol type in the current part depending on previously recovered symbols of a symbol sequence of a given symbol type in the current part, if the high efficiency mode is activated, or to keep its selection constant in the current part, if the low complexity mode is activated. That is, the selector 402 may be able to change the selection between the entropy decoders 322 for a given symbol type, but these changes are limited to occur during transitions between consecutive parts. With such an approach, the evaluation of the actual symbol statistics is limited to rare time events, while the coding complexity is reduced during the majority of the time.

[0139] Furthermore, each symbol of the symbol sequence 326 may be associated with a respective one of a plurality of symbol types, and the selector 402 may be configured to select, for a given symbol of a given symbol type, one of a plurality of contexts depending on previously retrieved symbols of the symbol sequence 326, and to perform a selection between the entropy decoders 322 depending on a probability model associated with the selected context and to update the probability model associated with the selected context depending on the given symbol when the high efficiency mode is activated, while being configured to select one of a plurality of contexts depending on previously retrieved symbols of the symbol sequence 326, and to perform a selection between the entropy decoders 322 depending on a probability model associated with the selected context and to maintain the probability model associated with the selected context when the low complexity mode is activated. That is, the selector 402 may use context adaptability for certain syntax element types in both modes, while suppressing probability adaptation in the LC mode.

[0140] Alternatively, instead of suppressing the probability adaptation completely, the selector 402 may simply reduce the update rate of the probability adaptation in the LC mode compared to the HE mode.

[0141] Further, possible LC-PIPE specific aspects, i.e. aspects of the LC mode, may be restated as follows: In particular, a non-adaptive probability model can be used in the LC mode. The non-adaptive probability model may be hard-coded, i.e. have a constant probability globally, or may be held constant only during the processing of one slice, and thus be set depending on the slice type and the QP, i.e. the quantization parameter, e.g., signaled in the data stream 401 for each slice. By assuming that consecutive bins assigned to the same context follow a fixed probability model, it is possible to decode several of these bins in one step, i.e., using the same entropy decoder, as if they were encoded using the same PIPE code, and to omit the probability update after each decoded bin. Omitting the probability update saves operations during the encoding and decoding process, thus reducing the complexity and resulting in significant simplification in the hardware design.

[0142] The non-adaptive constraint may be relaxed in such a way that probability updates are allowed after a certain number of bins have been encoded / decoded using this model for all or some selected probability models. A suitable update interval allows probability adaptation while still having the ability to decode multiple bins at once.

[0143] In the following, aspects that are common to LC-PIPE and HE-PIPE and potentially scalable in complexity are described in more detail. In particular, in the following, aspects that can be used in the same way or in a scalable way in complexity are described for LC-PIPE and HE-PIPE modes. Scalable in complexity means that the LC case is derived from the HE case by removing the special parts or replacing them by something less complex. However, before this description, a note should be made: the embodiment of Fig. 11 can be easily transformed into the above-mentioned context-adaptive binary arithmetic coding / decoding embodiment, in which case the selection unit 402 and the entropy decoder 322 would be condensed into one context-adaptive binary arithmetic decoder that would directly receive the data stream 401 and select the context for the bin that is currently to be derived from the data stream. This is especially true for context adaptability and / or probability adaptability. In the low complexity mode, both functionality / adaptability may be switched off or designed to be more relaxed.

[0144] For example, in constructing the embodiment of FIG. 11, the PIPE entropy coding stage, including the entropy decoder 322, may use eight systematic variable-to-variable-codes. That is, each entropy decoder 322 may be a v2v type decoder as described above. The coding concept of PIPE using systematic v2v codes is simplified by limiting the number of v2v codes. In case of a context-adaptive binary arithmetic decoder, the decoder may also handle the same probability state for different contexts and use it - or a quantized version of it - for probability subdivision. The mapping from the state of the CABAC or probability model, i.e. the state used for probability update, to the probability index for reference in PIPEids or Rtab may be as shown in Table A.

[0145] [Table A]

[0146] This modified coding scheme may be used as a basis for a complexity-scalable video coding approach. In case of performing probability mode adaptation, the selector 402 or the context-adaptive binary arithmetic decoder may select the PIPE decoder 322, i.e. derive the PIPE index to be used and the probability index into Rtab, respectively, based on the probability state index (here illustratively in the range 0-62) associated with the currently to be decoded symbol (e.g. via the context), using the mapping shown in Table A, and may update said probability state index depending on the currently decoded symbol, for example using specific table walk transition values ​​pointing to the next probability state index to be consulted in the case of MPS and LPS, respectively. In case of LC mode, the latter update may not be performed. In case of a globally fixed probability model, even a mapping may not be performed.

[0147] However, any entropy coding setting can be used and the techniques presented herein can be used with minor adaptations.

[0148] The syntax elements and syntax element types were described somewhat generally above in the description of Figure 11. In the following, configurable coding of transform coefficient level complexity is described.

[0149] For example, the reconstruction unit 404 may be configured to reconstruct the transform block 200 of transform coefficient levels 202, regardless of whether the high efficiency mode or the low complexity mode is activated, based on a portion of the sequence of syntax elements 327, which may include, in a non-interleaved manner, a significance map syntax element defining one significance map indicating the positions of the non-zero transform coefficient levels in the transform block 200, followed by level syntax elements defining those non-zero transform coefficient levels. In particular, the following elements may be included: an end position syntax element (last_significant_pos_x, The significance map may further include a first syntax element (coeff_significant_flag), which together define a significance map, indicating for each position along a one-dimensional path (274) connecting from the DC position to the position of the last non-zero transform coefficient level in the transform block (200), whether the transform coefficient level at the respective position is non-zero, a second syntax element (coeff_abs_greater1) indicating for each position of the one-dimensional path (274) at which a non-zero transform coefficient level is located according to the first binary syntax element, whether the transform coefficient level at the respective position is greater than 1, and a third syntax element (coeff_abs_greater2, coeff_abs_minus3) indicating for each position of the one-dimensional path at which a transform coefficient level greater than 1 is located according to the first binary syntax element, the amount by which the respective transform coefficient level at the respective position exceeds 1.

[0150] The order between the end position syntax element, the first syntax element, the second syntax element and the third syntax element may be the same for the high efficiency mode and the low complexity mode, and further the selection unit 402 may be configured to perform the selection between the entropy decoder 322 for a symbol from which the desymbolizer 314 obtains the end position syntax element, the first syntax element, the second syntax element and / or the third syntax element differently depending on whether the low complexity mode or the high efficiency mode is activated.

[0151] In particular, the selection unit 402 may be configured to select, for each symbol of a given symbol type in a symbol subsequence from which the desymbolizer 314 obtains the first and second syntax elements, one of a plurality of contexts depending on previously retrieved symbols of the given symbol type in the symbol subsequence, or to perform the selection depending on a probability model associated with the selected context if the high efficiency mode is activated, or in a piecewise constant manner such that the selection is constant over a series of successive subportions of the subsequence if the low complexity mode is activated. As mentioned above, the subportions may be measured as the number of positions that the respective subportion extends over when measured along the one-dimensional path 274, or the number of syntax elements of the respective type that have already been encoded using the current context. That is, the binary syntax elements coeff_significant_flag, coeff_abs_greater1 and coeff_abs_greater2 are coded in a context-adaptive manner, for example by selecting the decoder 322 based on a probability model of the selected context in HE mode. Probability adaptation is also used. In LC mode, there are also different contexts used for each syntax element coeff_significant_flag, coeff_abs_greater1 and coeff_abs_greater2. However, for each of these syntax elements, the context is kept static for the first part along the path 274 and the context can only change at the transition to the next immediately following part along the path 274. For example, each part may be defined to have a length of 4, 8, 16 positions of the block 200, regardless of whether the syntax element is present for each position, respectively. For example, coeff_abs_greater1 and coeff_abs_greater2 are only present for significant positions, ie positions where coeff_significant_flag is 1.Alternatively, each portion may be defined to have a length of 4, 8, or 16 syntax elements, regardless of whether the resulting respective portion extends across more block positions. For example, coeff_abs_greater1 and coeff_abs_greater2 are only present for significant positions. Thus, each portion of four syntax elements may extend beyond four block positions, where no syntax elements such as coeff_abs_greater1 and coeff_abs_greater2 are transmitted at all for the positions along path 274 between, because their respective levels at this position are zero.

[0152] For symbols of a given symbol type in a symbol subsequence from which the desymbolizer obtains the first and second syntax elements, the selection unit 402 may be configured to select for each symbol of the given symbol type one of a number of contexts, the selection depending on the number of previously recovered symbols of the given symbol type in the symbol subsequence having the given symbol value and belonging to the same subpart or depending on the number of previously recovered symbols of the given symbol type in the sequence of symbols belonging to the same subpart. According to the above described embodiment, in the first alternative coeff_abs_greater1 is correct and in the second alternative coeff_abs_greater2 is correct.

[0153] Furthermore, for each position of the one-dimensional path where a transform coefficient level greater than one is located according to the first binary syntax element, the third syntax element indicating the amount by which the respective transform coefficient level at the respective position exceeds one may comprise an integer-valued syntax element, i.e. coeff_abs_minus3. The desymbolizer 314 may be configured to map the domain of the symbol sequence words to the co-domain of the integer-valued syntax elements using a mapping function controllable by a control parameter, and may be further configured to set the control parameter for each integer-valued syntax element in dependence on the integer-valued syntax element of the preceding third syntax element when the high efficiency mode is activated, and to perform the setting in a piecewise constant manner such that the setting is constant over a series of consecutive sub-portions of the subsequence when the low complexity mode is activated. However, the selector 402 is configured to select a given one of the entropy decoders (322) for the symbols of the symbol sequence words mapped to integer-valued syntax elements, which one may be associated with a uniform probability distribution in both the high efficiency mode and the low complexity mode. That is, even the desymbolizer may be operable depending on the mode selected by the switch 400, as indicated by the dotted line 407. Instead of a piece-wise constant setting of the control parameters, the desymbolizer 314 may hold the control parameters constant, for example for the duration of the current slice, or globally constant in time.

[0154] We then describe complexity-scalable context modeling.

[0155] Evaluating the same syntax element of the upper and left neighbors to derive the context model index is a common technique and is frequently used in the case of HE, for example for the motion vector difference syntax element. However, this evaluation requires a relatively large buffer storage and does not allow direct coding of the syntax element. Furthermore, to achieve higher coding performance, a larger number of valid neighbors may be evaluated.

[0156] In a preferred embodiment, all context modeling stages that evaluate syntax elements of neighboring square or rectangular blocks or prediction units are fixed to one context model. This is equivalent to disabling adaptivity in the context model selection stage. For that preferred embodiment, unlike the current CABAC design, the context model selection depending on the bin index of the bin string after binarization is not modified. In another preferred embodiment, in addition to the fixed context model with neighborhood evaluation for syntax elements, the context models for different bin indices are also fixed. Note that this description does not include binarization and context model selection for syntax elements related to coding of motion vector differences and transform coefficient levels.

[0157] In a preferred embodiment, only evaluation of the left neighbor is allowed, which results in a reduction of buffers in the processing chain since it is no longer necessary to store the last block or coding unit line, in another preferred embodiment, only neighbors within the same coding unit are evaluated.

[0158] In a preferred embodiment, all valid neighborhoods are evaluated, for example the upper left, upper right and lower left neighborhoods are evaluated for validity in addition to the upper and left neighborhoods.

[0159] That is, the selection unit 402 of Fig. 11 may be configured to select one of the multiple contexts for a given symbol associated with a given block of media data using previously retrieved symbols of symbol sequences associated with a larger number of different neighboring blocks of media data when the high efficiency mode is activated, and to perform selection between the entropy decoders 322 depending on a probability model associated with the selected context. That is, the neighboring blocks may be neighbors in the time and / or space domain. Spatially neighboring blocks are shown in Figs. 1 to 3, for example. In that case, the selection unit 402 may perform contact adaptation in response to the mode selection by the mode switch 400, where the adaptation is performed based on previously retrieved symbols or syntax elements associated with a larger number of neighboring blocks in the HE mode compared to the LC mode, thereby reducing storage overhead as described above.

[0160] Next, a reduced-complexity coding of motion vector differences according to one embodiment will be described.

[0161] In the H.264 / AVC video codec standard, the motion vector associated with a macroblock is transmitted by signaling the difference between the motion vector of the current macroblock and the central motion vector predictor (motion vector difference - mvd). When CABAC is used as the entropy coder, mvd is coded as follows: the integer value of mvd is split into an absolute value and a positive and negative sign part. The absolute value part is binarized using a combination of truncated unary and cubic exponential-Golomb and is referred to as the prefix and suffix of the resulting bin string. The bins associated with the truncated unary binarization are coded using the context model and the bins associated with the exponential-Golomb binarization are coded with a fixed probability with bypass mode, i.e. 0.5 for CABAC. The unary binarization is performed as follows: Let n be the integer value of the absolute value of mvd. Then the resulting bin string consists of n "1's" followed by one trailing "0". As an example, assume n=4. The bin string would then be "11110". In the case of truncated unaries, there is a limit, and if the value exceeds this limit, the bin string will have n+1 "1's". In the case of mvd, the limit is equal to 9. That is, if an absolute mvd of 9 or more is coded, 9 "1's" will result, and the bin string will be a prefix-suffix exponential-Golomb binarization. Context modeling for the truncated unary part is performed as follows: For the first bin of the bin string, the absolute mvd values ​​from the upper and left neighboring macroblocks are taken if available (otherwise the value is assumed to be 0). If the sum for a particular component (horizontal or vertical) is greater than 2, the second context model is selected. If the absolute sum is greater than 32, the third context model is selected, otherwise (absolute sum less than 3), the first context model is selected. Furthermore, the context model is different for each component.For the second bin of the bin string, the fourth context model is used, and the fifth context model is used for the remaining bins of the unary part. If the absolute mvd is greater than or equal to 9, e.g., if all bins of the truncated unary part are equal to "1", then the difference between the value of the absolute mvd and 9 is coded in bypass mode using third-order exponential-Golomb binarization. In the last step, the sign of the mvd is coded in bypass mode.

[0162] The latest coding techniques for mvd when using CABAC as entropy coder are specified in the current Test Model (HM) of the High Efficiency Video Coding (HEVC) project. In HEVC, the block size is variable and the shape specified by the motion vector is called Prediction Unit (PU). The PU size of the upper and left neighbors may have a different shape and size than the current PU. Therefore, whenever relevant, the definition of upper and left neighbors is referred to here as the upper and left neighbors of the upper-left corner of the current PU. As for the coding itself, only the derivation process for the first bin may vary depending on the embodiment. Instead of evaluating the absolute sum of MVs from the neighbors, each neighbor may be evaluated separately. If the absolute MV of a certain neighborhood is valid and exceeds 16, the context model index may be increased, resulting in the same number of context models for the first bin, while the coding of the remaining absolute MVD levels and signs may be exactly the same as H.264 / AVC.

[0163] In the technique for encoding mvd described above, up to 9 bins may be encoded using a context model, while the remaining values ​​of mvd may be encoded in a low-complexity bypass mode together with the sign information. The technique described in this embodiment reduces the number of bins encoded in the context model, thus increasing the number of bypasses and further reducing the number of context models required for encoding mvd. Therefore, the cutoff value is reduced from 9 to 1 or 2. That is, only the first bin that identifies whether the absolute value mvd is greater than zero or not is encoded using a context model, or only the first and second bins that identify whether the absolute value mvd is greater than zero and 1 are encoded using a context model, while the remaining values ​​are encoded using a bypass mode and / or a VLC code. All bins resulting from the binarization using VLC codes, without using unary codes or truncated unary codes, are encoded using a low-complexity bypass mode. In the case of PIPE, direct insertion into and out of the bitstream is possible. Furthermore, different definitions of upper and left neighborhoods may be used when they exist to derive a better context model selection for the first bin.

[0164] In a preferred embodiment, an exponential-Golomb code is used to binarize the remaining part of the absolute MVD component. Therefore, the order of the exponential-Golomb code is variable. The order of the exponential-Golomb code is derived as follows: After the context model for the first bin and the index of the context model are derived and coded, the index is used as the order of the exponential-Golomb binarization part. In this preferred embodiment, the context model for the first bin is in the range of 1 to 3, resulting in an index of 0 to 2, which are used as the order of the exponential-Golomb code. This preferred embodiment can be used for the HE case.

[0165] As an alternative to the technique of using 2×5 contexts as described above in the coding of absolute value MVD, 14 context models (7 for each component) may be used to code the 9 unary code binarization bins. For example, the first and second bins of the unary part may be coded using 4 different contexts as described above, while the fifth context may be used for the third bin, the sixth context for the fourth bin, and the fifth to ninth bins may be coded using the seventh context. Thus, in this case, 14 contexts may be required, and it may even happen that only the remaining values ​​can be coded in low-complexity bypass mode. A technique to reduce the number of bins coded using context models and thus increase the number of bypasses, and also to reduce the number of context models required for coding the MVD, is to reduce the cutoff value, for example from 9 to 1 or 2. That is, only the first bin that identifies whether the absolute MVD is greater than zero or not is coded using the context model, or only the first and second bins that identify whether the absolute MVD is greater than zero and one are coded using the respective context models, while the remaining values ​​are coded using the VLC code. All bins resulting from the binarization using the VLC code are coded using a low-complexity bypass mode. In the case of PIPE, direct insertion into and out of the bitstream is possible. Furthermore, the proposed embodiment uses different definitions of the upper and left neighborhoods to derive a better context model selection for the first bin. In addition to this, the context modeling may be modified in such a way that the number of context models required for the first bin or the first and second bins is reduced, which may result in further memory reduction. It is also possible to disable the evaluation of neighborhoods such as the upper neighborhood, which may result in saving line buffers / memory required for storing the mvd values ​​of the neighborhood.Finally, the coding order of the above components may be split in a way that allows the coding of bypass bins after the coding of the prefix bins for both components (i.e., the bins that are coded using the context model).

[0166] In a preferred embodiment, an exponential-Golomb code is used to binarize the remaining part of the absolute mvd component. Therefore, the order of the exponential-Golomb code is variable. The order of the exponential-Golomb code may be derived as follows: After the context model for the first bin and the index of the context model are derived, the index is used as the order of the exponential-Golomb binarization. In this preferred embodiment, the context model for the first bin is in the range of 1 to 3, so that the index is 0 to 2, which is used as the order of the exponential-Golomb code. This preferred embodiment can be used for the HE case, and the number of context models is reduced to 6. To again reduce the number of context models and thus save memory, in a further embodiment, the horizontal and vertical components may share the same context model. In that case, only three context models are needed. Furthermore, in a further preferred embodiment of the present invention, only the left neighbor may be considered for the evaluation. In this preferred embodiment, the thresholds can be unmodified (e.g. a single threshold 16 with exponential-Golomb parameters of 0 or 1, or a single threshold 32 with exponential-Golomb parameters of 0 or 2). This preferred embodiment saves on line buffers required for storing mvd values. In another preferred embodiment, the thresholds are modified and are equal to 2 and 16. For that preferred embodiment, a total of three context models are required for encoding the mvd, with possible exponential-Golomb parameters ranging from 0 to 2. In a further preferred embodiment, the thresholds are equal to 16 and 32. This embodiment is also suitable for the HE case.

[0167] In a further preferred embodiment of the present invention, the cutoff value is reduced from 9 to 2. In this preferred embodiment, the first and second bins may be coded with a context model. The selection of the context model for the first bin may be performed according to the state of the art or modified according to the preferred embodiment described above. For the second bin, a different context model is selected as in the state of the art. In a further preferred embodiment, the context model for the second bin is selected by evaluating the mvd of the left neighborhood. In that case, the context model index is the same as that of the first bin, but the effective context model is different from that of the first bin. In total, six context models are required (note that the components share a context model). Again, the exponential-Golomb parameter may depend on the selected context model index of the first bin. In another preferred embodiment of the present invention, the exponential-Golomb parameter depends on the context model index of the second bin. This embodiment of the present invention can also be used in the case of HE.

[0168] In a further preferred embodiment of the present invention, the context models for both bins are fixed and are not derived by evaluating left or upper neighbors. For this preferred embodiment, the total number of context models is equal to 2. In a further preferred embodiment of the present invention, the first bin and the second bin share the same context model. As a result, only one context model is needed for the encoding of the mvd. In both preferred embodiments of the present invention, the exponential-Golomb parameter is fixed and may be equal to 1. This preferred embodiment of the present invention is suitable for both HE and LC configurations.

[0169] In another preferred embodiment, the order of the exponential-Golomb portion is derived independently from the context model index of the first bin. In this case, the absolute sum of the normal context model selection of H.264 / AV is used to derive the order of the exponential-Golomb portion. This preferred embodiment is appropriate for HE implementations.

[0170] In another preferred embodiment, the degree of the exponential-Golomb code is fixed and set to 0. In another preferred embodiment, the degree of the exponential-Golomb code is fixed and set to 1. In yet another preferred embodiment, the degree of the exponential-Golomb code is fixed to 2. In yet another embodiment, the degree of the exponential-Golomb code is fixed to 3. In yet another embodiment, the degree of the exponential-Golomb code is fixed based on the shape and size of the current PU. These proposed embodiments can be used in the LC case. Note that the fixed degree of the exponential-Golomb part is considered with a small number of bins coded using the context model.

[0171] In one preferred embodiment, the neighborhood is defined as follows: for the upper PU, all PUs covering the current PU are considered and the PU with the maximum MV is used. The same method is applied to the left neighborhood: all PUs covering the current PU are evaluated and the PU with the maximum MV is used. In another preferred embodiment, the average absolute motion vector value from all PUs covering the upper and left borders of the current PU is used to derive the first bin.

[0172] In the preferred embodiment proposed above, the coding order can also be changed as follows: the mvds have to be specified for the horizontal and vertical directions one after the other (or vice versa). Thus, two bin strings need to be coded. In order to minimize the number of mode switches for the entropy coding engine (i.e., between bypass and normal mode), it is possible to code the bins coded with the context models for both components in a first step, and then code the bins coded in bypass mode in a second step. Note that this only states the order.

[0173] Note that the bins resulting from unary or truncated unary binarization can also be represented by an equivalent fixed-length binarization, one flag per bin index that specifies whether its value is greater than the current bin index. As an example, if the cutoff value of the truncated unary binarization of mvd is set to 2, then for values ​​0, 1, 2 the codewords are 0, 10, 11. In the corresponding equivalent fixed-length binarization with one flag per bin index, one flag for bin index 0 (i.e. the first bin) specifies whether the value of absolute value mvd is greater than 0, and one flag for the second bin with bin index 1 specifies whether the value of absolute value mvd is greater than 1. If the second flag is coded only when the first flag is equal to 1, the same codewords 0, 10, 11 are obtained as a result.

[0174] Next, we describe a complexity-scalable representation of the internal state of a probabilistic model according to one embodiment.

[0175] In the HE-PIPE setup, the internal state of a probability model is updated after encoding a bin with it. The updated state is derived by a state transition table lookup using the old state and the encoded bin value. In the case of CABAC, a probability model can have 63 different states, where each state corresponds to one model probability in the interval (0.0,0.5). Each of these states is used to realize two model probabilities. In addition to the probability assigned to the state, 1.0 minus the probability is also used, and a flag called valMps remembers whether that probability or 1.0 minus the probability was used. So, in total, there are 126 states. To use such a probability model with the PIPE coding concept, each of the 126 states needs to be mapped to one of the valid PIPE coders. In the current implementation of the PIPE coder, this is done using a lookup table. An example of such a mapping is shown in Table A.

[0176] The following embodiment describes how the internal state of a probabilistic model can be represented to avoid the use of lookup tables to convert the internal state to a PIPE index. Only a simple bit masking operation is needed to extract the PIPE index from the internal state variables of the probabilistic model. This novel representation of the internal state of a probabilistic model, with scalable complexity, is designed in a two-level way. For applications where low complexity operations are essential, only the first level is used. It describes only the pipe index and the flag valMps used to encode or decode the associated bin. In the case of the PIPE entropy coding scheme described above, the first level may be used to distinguish between eight different model probabilities. Thus, the first level would require three bits for pipeIdx and one more bit for the valMps flag. In the second level, each of the coarse probability ranges of the first level is refined into several smaller intervals that support a higher resolution representation of the probabilities. Such a more detailed representation allows for more precise manipulation of probability estimators. In general, it is appropriate for coding applications aiming for high RD performance. As an example, this complexity-scalable representation of the internal state of a probability model using PIPE is shown below.

[0177] TIFF2025004187000006.tif33150

[0178] The first and second levels are stored in a single 8-bit memory. Four bits are needed to store the first level - the PIPE index and the value of the MPS for the most significant bit - and another four bits are used to store the second level. To perform the behavior of the CABAC probability estimate, each PIPE index has a certain number of allowed refinement indices, depending on how many CABAC states are mapped to the PIPE index. For example, the number of CABAC states per each PIPE index for the mapping of Table A is shown in Table B.

[0179] TIFF2025004187000007.tif26150

[0180] During the bin encoding or decoding process, the PIPE index and valMps can be accessed directly using simple bit mask or bit shift operations. A low-complexity encoding process requires only 4 bits of the first level, while a high-efficiency encoding process utilizes an additional 4 bits of the second level to perform a probability model update of the CABAC probability estimates. To perform this update, a state transition lookup table may be designed to use a two-level representation of states that is scalable in complexity while performing the same state transitions as the original table. The original state transition table consists of 2×63 elements. For each input state, the table contains two output states. When using a representation that is scalable in complexity, the size of the state transition table does not exceed 2×128 elements, which is an acceptable increase in table size. This increase depends on how many bits are used to represent the refinement index; 4 bits are needed to accurately mimic the behavior of the CABAC probability estimates. However, a different probability estimate may be used that can operate on a reduced set of CABAC states that allows for no more than 8 states for each pipe index. Thus, by adapting the number of bits used to represent the refinement index, the memory consumption can be matched to a given complexity level of the encoding process. Unlike the internal state of the model probabilities with CABAC, where there are 64 probability state indices, the use of table lookups to map the model probabilities to a specific PIPE code is avoided and no further conversion is required.

[0181] Next, a complexity-scalable context model update according to one embodiment will be described.

[0182] To update a context model, its probability state index may be updated based on one or more previously coded bins. In a HE-PIPE setup, this update is performed after the coding or decoding of each bin. Conversely, in a LC-PIPE setup, this update may not be performed even once.

[0183] However, it is possible to perform the context model update in a way that is scalable in complexity, i.e. the decision to update a context model or not may be based on various aspects, for example a coder setup may not perform an update only for certain context models, e.g. the context model of the syntax element coeff_significant_flag, while always performing an update for all other context models.

[0184] In other words, the selection unit 402 is configured to perform a selection between the entropy decoders 322 for each symbol of several predefined symbol types, where the number of predefined symbol types may be selected to be smaller in the low complexity mode than in the high efficiency mode depending on the respective probability model associated with each predefined symbol.

[0185] Furthermore, the criterion controlling whether to update the context model may be, for example, the size of the bitstream packet or the number of bins decoded so far, or the update may be performed only after encoding a certain fixed or variable number of bins for the context model.

[0186] Using this scheme for deciding whether to update the context model, a context model update that is scalable in complexity can be implemented. The update can increase or decrease the portion of bins in the bitstream where the context model update is performed. The more the number of context model updates, the better the coding efficiency and the higher the computational complexity. Thus, using the above scheme, a context model update that is scalable in complexity can be achieved.

[0187] In a preferred embodiment, the context model update is performed for the bins of all syntax elements except for the syntax elements coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2.

[0188] In a further embodiment, the context model update is performed only for the bins of the syntax elements coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2.

[0189] In a further embodiment, context model updates are performed for all context models when encoding or decoding of a slice begins, and after a certain predetermined number of transform blocks are processed, context model updates are disabled for all context models until the end of the slice is reached.

[0190] For example, the selection unit 402 may perform the selection between the entropy decoders 322 for symbols of a given symbol type depending on a probability model associated with the given symbol type, with or without updating the associated probability model, in which case the length of the learning phase of the symbol sequence in which the selection for symbols of a given symbol type is performed with said updating may be configured to be shorter in the low complexity mode than in the high efficiency mode.

[0191] Another preferred embodiment is similar to the previously described preferred embodiment, except that this embodiment uses a representation that is scalable in the complexity of the internal state of the context models, in that one table stores the "first part" (valMps and pipeIdx) of all context models, and a second table stores the "second part" (refineIdx) of all context models. At the point where context model updates are disabled for all context models (as described in the previously described preferred embodiment), the table storing the "second part" becomes unnecessary and can therefore be deleted.

[0192] Next, a context model update for a bin sequence according to one embodiment will be described.

[0193] In the construction of LC-PIPE, the bins of syntax elements of type coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 are grouped into subsets. For each subset, a single context model is used to code that bin. In this case, a context model update may be performed after coding a fixed number of bins of the sequence. This is called a multi-bin update in the following. However, this update may be different from the update that uses the last bin and the internal state of the context model. For example, one context model update step may be performed for each coded bin.

[0194] Below is an example for encoding an exemplary subset of 8 bins. The letter "b" represents the decoding of one bin, and the letter "u" represents the update of the context model. In the case of LC-PIPE, only the bin decoding is performed without performing the context model update. bbbbbbbb

[0195] In the case of HE-PIPE, a context model update is performed after the decoding of each bin. bubububububububu

[0196] To reduce the complexity somewhat, the context model update may be performed after the bin sequence (in this example, an update of these four bins is performed after the decoding of every four bins). bbbbuuuubbbbuuuu

[0197] That is, the selection unit 402 may be configured to perform a selection between the entropy decoders 322 for symbols of a given symbol type depending on a probability model associated with the given symbol type, with or without updating the associated probability model, in which case the number of times selection for symbols of a given symbol type with said updates is performed may be configured to be lower in the low complexity mode than in the high efficiency mode.

[0198] In this case, the decoding of the four bins is followed by four update steps based on the four bins just decoded. Note that these four update steps can also be performed by a single step with reference to a special lookup table. This lookup table stores, for each possible combination of the four bins and each possible internal state of the context model, the new state resulting after the four conventional update steps.

[0199] In one mode, a multi-bin update is used for the syntax element coeff_significant_flag. For all other syntax elements, no context model update is used. The number of bins to be coded before the multi-bin update step is performed is set to n. If the number of bins in the set is not divisible by n, then 1 to n-1 bins remain at the end of the subset after the last multi-bin update. For each of these bins, a conventional single-bin update is performed after coding of all these bins. The number n may be any positive number greater than 1. Other modes may be identical to the previous modes, except that a multi-bin update is performed for any combination of coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 (instead of only coeff_significant_flag). Thus, this mode may be more complex than the other modes. All other syntax elements (for which multi-bin updates are not used) can be split into two disjoint subsets, where for one of the subsets single-bin updates are used and for the other subset no context model updates are used. Any possible disjoint subset (including the empty subset) is valid.

[0200] In an alternative embodiment, the multi-bin update may be based only on the last m bins encoded immediately before the multi-bin update step, where m may be any natural number less than n. Thus, the decoding may be performed as follows: bbbbuubbbbuubbbbuubbbb... However, n=4 and m=2.

[0201] That is, the selector 402 may select between the entropy decoders 322 for symbols of a given symbol type depending on a probability model associated with the given symbol type, and may update the associated probability model for every n-th symbol of the given symbol type based on the m most recent symbols of the given symbol type, and may be configured such that in the low complexity mode the ratio n / m is higher than in the high efficiency mode.

[0202] In a further preferred embodiment, for the syntax element coeff_significant_flag, a context modeling scheme using local templates as described above for HE-PIPE may be used to assign context models to the bins of the syntax element, however, for these bins, no context model updates are used.

[0203] Furthermore, the selection unit 402 may select one of a number of contexts for a symbol of a given symbol type depending on the number of previously retrieved symbols in the symbol sequence, and may select between the entropy decoders 322 depending on a probability model associated with the selected context, in which case the number of contexts and / or the number of previously retrieved symbols may be lower in the low complexity mode than in the high efficiency mode.

[0204] <Probabilistic model initialization using 8-bit initialization value> This chapter describes a complexity scalable probability model internal state initialization process that uses a so-called 8-bit initialization value instead of two 8-bit values ​​as in the state-of-the-art video coding standard H.265 / AVC. This 8-bit initialization value consists of two parts, comparable to the pair of initialization values ​​used for the probability model in CABAC of H.264 / AVC. These two parts represent two parameters of a linear equation for computing the internal state of the probability model that represents a particular probability (e.g. in the form of a PIPE index) from a certain QP. The first part describes the gradient, which exploits the dependency of the internal state on the quantization parameter (QP) used during encoding or decoding. - The second part defines the PIPE index and valMps for a given QP.

[0205] Two different modes are available for initializing a probabilistic model using a given initialization value. The first mode is called QP-independent initialization. It uses only the PIPE index and valMps defined in the second part of the initialization value for all QPs. This is the same as when the slope is equal to 0. The second mode is called QP-dependent initialization, which additionally uses the slope of the first part of the initialization value to modify the PIPE index and define the refinement index. The two parts of the 8-bit initialization value are represented as follows:

[0206] TIFF2025004187000008.tif31150

[0207] It consists of two 4-bit parts. The first part contains an index that points to one of 16 different predefined slopes stored in an array. The predefined slopes consist of 7 negative slopes (slope index 0-6), one slope equal to zero (slope index 7) and 8 positive slopes (slope index 8-15). The slopes are shown in Table C.

[0208] TIFF2025004187000009.tif49150

[0209] To avoid the use of floating-point arithmetic, all values ​​are scaled by a factor of 256. The second part is a PIPE index that embodies the increasing probability of valMps=1 between the probability interval p=0 and p=1. In other words, PIPE coder n must operate with a higher model probability than PIPE coder n-1. For each probability model, one PIPE probability index is valid, which determines whether the probability interval is p for QP=26.valMPs=1 A PIPE coder containing the probability of is identified.

[0210] TIFF2025004187000010.tif56150

[0211] QP and the 8-bit initialization value are needed to calculate the initialization of the internal states of the probability model by computing a simple linear equation of the form y=m*(QP-QPref)+256*b. Note that m defines the slope derived from Table C using the slope index (first part of the 8-bit initialization value), and b indicates the PIPE coder (second part of the 8-bit initialization value: "PIPE probability index") at QPref=26. Then, if y is greater than 2047, valMps is 1 and pipeIdx is equal to (y-2048)>>8. Otherwise, valMps is 0 and pipeIdx is equal to (2047-y)>>8. If valMps is equal to 1, the refinement index is equal to (((y-2048)&255)*numStates)>>8. Otherwise, the refinement index is equal to (((2047-y)&255)*numStates)>>8. In both cases, numStates is equal to the number of CABAC states for pipeIdx as shown in Table B.

[0212] The above scheme can be used not only in combination with the PIPE coder, but also in combination with the above CABAC scheme. Without PIPE, some CABAC states, i.e., probability states (pState_current[bin]) where state transitions for probability updates for each PIPEIdx (i.e., each most significant bit of pState_current[bin]) are performed, are actually just a set of parameters that realize a piecewise linear interpolation of CABAC states depending on the QP. Furthermore, this piecewise linear interpolation can also be virtually disabled if the parameter numStates uses the same value for all PIPEIdx. For example, setting numStates to 8 for all cases results in a total of 16*8 states, and the refinement index calculation is simplified to ((y-2048)&255)>>5 when valMps is equal to 1, or ((2047-y)&255) when valMps is equal to 0. In this case, it is very easy to map back the representation using valMps, PIPEIdx and refinement index to the representation used by the original CABAC in H.264 / AVC: the CABAC state is given as (PIPEIdx<<3)+refinement index, as will be further explained below with reference to FIG.

[0213] If the slope of the 8-bit initialization value is not equal to zero or the QP is not equal to 26, the internal state needs to be calculated by using a linear equation with the QP of the encoding or decoding process. If the slope is equal to zero or the QP of the current encoding process is equal to 26, the second part of the 8-bit initialization value can be directly used to initialize the internal state of the probability model. In other cases, the decimal part of the resulting internal state may be further used to determine the refinement index in the application of high efficiency coding by linear interpolation between the limit values ​​of a specific PIPE coder. In this preferred embodiment, the linear interpolation is performed by simply multiplying the decimal part by the total number of refinement indexes available for the current PIPE coder and mapping the result to the nearest integer refinement index.

[0214] The process of initialization of the internal state of the probability model can vary with respect to the number of PIPE probability index states. In particular, the double occurrence of equally likely modes using PIPE coder E1, i.e., the use of two different PIPE indices to distinguish between MPS being 1 or 0, can be avoided as follows. Again, this process can be invoked during the beginning of the analysis of the slice data, and furthermore, the input of this process can be an 8-bit initialization value as shown in Table E, which can be transmitted, for example, in the bitstream for each context model to be initialized.

[0215] TIFF2025004187000011.tif32150

[0216] The first four bits define a slope index and are recovered by masking bits b4 through b7. For each slope index, one slope (m) is specified and is shown in Table F.

[0217] TIFF2025004187000012.tif29150

[0218] Bits b0 through b3, i.e. the last 4 bits of the 8-bit initialization value, identify the probIdx and describe the probability at a given QP. probIdx 0 indicates the highest probability for a symbol having value 0, probIdx 14 indicates the highest probability for a symbol having value 1. Table G shows, for each probIdx, the corresponding pipeCoder and its valMps.

[0219] TIFF2025004187000013.tif40150

[0220] The computation of the internal state is performed using both values, using a linear equation such as y=m*x+256*b, where m denotes the slope, x denotes the QP of the current slice, and b is derived from probIdx as described below. All values ​​in this process are scaled by a factor of 256 to avoid the use of floating point arithmetic. The output of this process (y) represents the internal state of the probability model at the current QP and is stored in 8-bit memory. As shown in Table G, the internal state consists of valMps, pipeIdx, and refineIdx.

[0221] TIFF2025004187000014.tif29150

[0222] The assignment of refineIdx and pipeIdx is analogous to the internal state (pStateCtx) of the CABAC probabilistic model and is shown in Table H.

[0223] TIFF2025004187000015.tif82150

[0224] In a preferred embodiment, probIdx is defined in QP26. Based on the 8-bit initialization value, the internal state of one probability model (valMps, pipeIdx, and refineIdx) is processed as described in the following pseudocode. TIFF2025004187000016.tif106150

[0225] As shown in the pseudocode above, refineIdx is calculated by linearly interpolating between intervals of pipeIdx and quantizing the result to the corresponding refineIdx. The offset specifies the total number of refineIdx for each pipeIdx. The interval [7,8) of fullCtxState / 256 is divided in half. The interval [7,7.5) maps to pipeIdx=0 and valMps=0, and the interval [7.5,8) maps to pipeIdx=0 and valMps=1. Figure 15 illustrates the process of deriving the internal state and shows the mapping of fullCtxState / 256 to pStateCtx.

[0226] Note that the slope indicates the dependency of probIdx and QP. If the 8-bit initialization value slopeIdx is equal to 7, the internal state of the resulting probability model will be the same for all slice QPs, and thus the initialization process of the internal state will be independent of the current QP of the slice.

[0227] That is, the selector 402 may use the syntax element indicating the quantization step size QP to initialize a pipe index to be used in decoding a subsequent portion of the data stream, such as the entire stream or the next slice, that is used to quantize the data of this subsequent portion, such as the transform coefficient levels contained therein, using this syntax element as an index into one table common to both LC and HE modes. A table such as Table D may contain a pipe index for each reference QPref for each symbol type, or other data for each symbol type. Depending on the actual QP of the current portion, the selector may use the respective table entry a indicated by the actual QP and the QP itself to calculate a pipe index value, such as by multiplying a by (QP-QPref). The only difference between LC and HE modes is that the selector calculates the result with less precision in LC mode than in HE mode. The selector may, for example, use only the integer part of the result. In HE mode, a higher precision residual, such as a fractional part, is used to select one of the valid refinement indexes for each pipe index indicated by the lower precision or integer part. The refinement index is used in HE mode (and potentially more rarely in LC mode) to perform probability adaptation, such as by using the table walk described above. If the valid index for the current pipe index remains at its high bound, then the higher pipe index is selected by minimizing the refinement index. If the valid index for the current pipe index remains at its low bound, then the next lower pipe index is selected by maximizing the refinement index to the maximum value valid for the new pipe index. Although the pipe index and refinement index define the probability state, for selection between partial streams the selector uses only the pipe index.The refinement index only serves to track the probabilistic model more closely or with finer accuracy.

[0228] However, the above description shows that scalability in complexity can also be achieved with a decoder as shown in Fig. 12, independent of the PIPE or CABAC coding concepts of Figs. 7 to 17. The decoder of Fig. 12 is for decoding a data stream 601 in which media data are encoded and comprises a mode switch 600 configured to activate a low complexity mode or a high efficiency mode depending on the data stream 601, and a desymbolizer 602 configured to desymbolize a symbol sequence 603 obtained from the data stream 601 - either directly or for example via entropy decoding - using a mapping function controllable by a control parameter to obtain integer-valued syntax elements 604. The mapping function is for mapping the domain of the symbol sequence words to the co-domain of the integer-valued syntax elements. A reconstruction unit 605 is configured to reconstruct the media data 606 based on the integer-valued syntax elements. The desymbolizer 602 is configured to perform the desymbolization as follows: That is, the control parameters are configured to vary with the data stream at a first rate when the high efficiency mode is activated, as indicated by arrow 607, whereas when the low complexity mode is activated, the control parameters are either constant independent of the data stream, or vary with the data stream but at a second rate that is slower than the first rate. For example, the control parameters may vary with previously de-symbolized symbols.

[0229] Some of the above-mentioned embodiments used the aspect of Fig. 12. The syntax elements coeff_abs_minus3 and MVD in column 327 were binarized in the desymbolizer 314 depending on the selected mode, as indicated by the arrow 407, and the reconstruction unit 605 used these syntax elements for reconstruction. It is obvious that both aspects of Fig. 11 and Fig. 12 can be easily combined, but the aspect of Fig. 12 can also be combined with other coding environments.

[0230] See, for example, the motion vector difference coding described above. The desymbolizer 602 may be configured such that, in a first interval of the domain of integer-valued syntax elements below the cutoff value, the mapping function uses a truncated unary code to perform the mapping, and in a second interval of the domain of integer-valued syntax elements equal to or greater than the cutoff value, a combination of a prefix having the form of a truncated unary code for the cutoff value and a suffix having the form of a VLC codeword, where the decoder may include an entropy decoder 608 configured to derive some first bins of the truncated unary code from the data stream 601 using entropy decoding with a variable probability estimate and some second bins of the VLC codeword using a bypass mode with constant equal probability. In the HE mode, the entropy coding may be more complex than the LC coding, as indicated by the arrow 609. That is, context adaptability and / or probability adaptation may be applied in HE mode and suppressed in LC mode, or the complexity may be scaled with respect to other conditions, as described above with respect to various embodiments.

[0231] An encoder for encoding media data into a data stream, compatible with the decoder of Fig. 11, is shown in Fig. 13. The encoder may include an insertion unit 500 configured to signal activation of a low-complexity mode or a high-efficiency mode in a data stream 501, a constructor 504 configured to precode media data 505 into a sequence of syntax elements 506, a symbolizer 507 configured to symbolize the sequence of syntax elements 506 into a sequence of symbols 508, a number of entropy encoders 310 each configured to convert a partial sequence of symbols into a codeword of the data stream, and a selector 502 configured to send each symbol of the sequence of symbols 508 to a selected one of the number of entropy encoders 310, where the selector 502 may be configured to perform its selection depending on the activated one of the low-complexity mode and the high-efficiency mode, as indicated by arrow 511. Optionally, an interleaver 510 may be provided for interleaving the codewords of the encoder 310.

[0232] An encoder for encoding media data into a data stream, compatible with the decoder of Fig. 12, is shown in Fig. 14. The encoder comprises an insertion unit 700 arranged to signal in a data stream 701 the activation of a low-complexity mode or a high-efficiency mode, a construction unit 704 arranged to precode media data 705 into a syntax element sequence 706 including integer-valued syntax elements, and a symbolizer 707 for mapping the domain of the integer-valued syntax elements into a co-domain of symbol sequence words, the symbolizer 707 arranged to symbolize the integer-valued syntax elements using a mapping function controllable by a control parameter, where the symbolizer 707 is arranged to perform the symbolization as follows: the control parameter is arranged to vary with the data stream at a first rate when the high-efficiency mode is activated, as indicated by the arrow 708, while when the low-complexity mode is activated the control parameter is arranged to be constant independently of the data stream or to vary with the data stream but at a second rate lower than the first rate. The result of the symbolization is encoded into a data stream 701 .

[0233] It is noted that the embodiment of Fig. 14 can be easily transformed into the above-mentioned context-adaptive binary arithmetic coding / decoding embodiment. In that case, the selector 509 and the entropy coder 310 would be condensed into one context-adaptive binary arithmetic encoder, which would directly output the data stream 401 and select the context for the bin that is currently to be derived from the data stream. This is especially true for the context adaptivity and / or the probability adaptivity. In a low-complexity mode, both the functionality / adaptivity may be switched off or designed to be more relaxed.

[0234] It has been briefly mentioned above that the mode switching capability as described with respect to some of the above embodiments may be absent in other embodiments. To clarify this point, please refer to Fig. 16, which is used in the description since the embodiment of Fig. 16 differs from the above-mentioned embodiments only in that the mode switching capability has been eliminated. Furthermore, the following description will make clear the advantages that result from initializing the context probability estimates using less precise parameters for slope and offset than, for example, H.264.

[0235] In particular, Figure 16 shows a decoder for decoding video from a data stream 401 in which the syntax element 327 is encoded, using a binarization of the syntax element 327. It should be noted that in the above description, all details mentioned with respect to Figures 1 to 15 can also be transferred to the items shown in Figure 16, as far as, for example, the functionality of the desymbolizer 314, the reconstructor 404 and the entropy decoder 409 are concerned. However, for the sake of completeness, some of these details are described again below.

[0236] The decoder comprises an entropy decoder 409 configured to derive several bins 36 of the binarization from the data stream 401 using a binary entropy decoding, by selecting one of the different contexts and updating the probability states associated with the different contexts depending on previously decoded parts of the data stream 401. More specifically, as mentioned above, the entropy decoder 409 may be configured to derive several bins 326 of the binarization from the data stream 401 using a binary entropy decoding, such as the above mentioned CABAC scheme or a binary PIPE decoding, i.e. using a structure including several entropy decoders 322 operating in parallel and respective selection / assignment units. As far as the context selection is concerned, its dependency on previously decoded parts of the data stream 401 may be embodied as mentioned above. That is, the entropy decoder may be configured to perform a context selection for a bin currently to be derived depending on the position of the bin currently to be derived in the binarization to which the bin currently to be derived belongs, the syntax element type of a syntax element whose integer value is obtained by debinarizing the binarization to which the bin currently to be derived belongs, or the integer values ​​of one or more bins or previously debinarized syntax elements previously derived from the data stream 401. For example, the selected context may be different between the first and second bins of the binarization of a given syntax element. Furthermore, different groups of contexts may be provided for different syntax element types, such as transform coefficient levels, motion vector differences, coding mode parameters, etc.

[0237] As far as the probability state update is concerned, the entropy decoder 409 may be configured to perform the update for the currently derived bin by transitioning from a current probability state associated with a context selected for the currently derived bin out of 126 probability states to a new probability state out of 126 depending on the currently derived bin. As mentioned above, the entropy decoder 409 may access a table entry using, for example, the current state and the currently derived bin value, which may indicate a new probability state. See tables Next_State_LPS and Next_State_MPS above. In addition to the other steps 0 to 5 mentioned above, a table lookup for these tables is performed by the entropy decoder. In the above description, the probability state was sometimes represented as pState_current[bin]. Also, as mentioned above, the entropy decoder 409 may be configured to quantize a current probability interval bit value (R) representing the current probability interval to obtain a probability interval index q_index, and further to perform an interval subdivision to perform binary arithmetic decoding of the bin currently to be derived by indexing one of the table entries (Rtab) using the probability interval index and a probability state index p_state that depends on the current probability state associated with the selected context for the bin currently to be derived to sub-divide the current probability interval into two sub-intervals. As mentioned above, the entropy decoder 409 may use an 8-bit representation for the value R of the current probability interval width. To quantize the value of the current probability interval width, the entropy decoder 409 may, for example, take the two or three most significant bits of the 8-bit representation.

[0238] The entropy decoder 409 may then perform a selection between the two sub-intervals based on the value of the offset state from within the current probability interval, update the value of the probability interval width and the value of the offset state, further infer the value of the bin currently to be derived using the selected sub-interval, and perform a re-normalization of the updated probability interval width and the value of the offset state, i.e., V in the above description, which may include continuing to read bits from the data stream 401. As mentioned above, the selection between the two sub-intervals based on the value of the offset state V may include a comparison between R and V, while the update of the value of the probability interval width and the offset state value may depend on the value of the bin currently to be derived.

[0239] Continuing with the description of FIG. 16, the decoder further includes a desymbolizer 314 configured to debinarize the binarization of the syntax element 327 to obtain an integer value of the syntax element. The decoder of FIG. 16 further includes a reconstruction unit 404 which then reconstructs the video 405 based on the integer value of the syntax element using a quantization parameter QP. For example, the reconstruction unit 404 may operate in a predictive manner as described above, and may also use the quantization parameter to set the accuracy for representing the prediction residual, such as the transform coefficient levels representing a transformed version of the prediction residual. The entropy decoder 409 is configured to distinguish between 126 probability states as described above. That is, pState_current[bin] in combination with an indication of valMPS, i.e. an indication of MBS between 0 and 1, i.e. between the possible symbol states, can assume 126 different states. The entropy decoder 409 initializes the probability states associated with the various contexts, i.e., pState_current for the various valid contexts, according to the linear equation of the quantization parameters, i.e., the equation a·QP+d. Recall that pState_current actually indicates only the probability of the LSBs. Thus, a·QP+d represents both, i.e., pState_current and valMPS, which of the two states is the MBS and which is the LBS. While a·QP+d indicates the probability of a certain symbol, i.e., 1 or 0, the fact of whether a·QP+d is greater than 63 or not directly indicates whether 0 or 1 is the MSB or not. The entropy decoder 126 derives, for each of the various contexts, the slope a and the offset b of the linear equation from the first and second 4-bit parts of the respective 8-bit initialization value, i.e., the 4 MSBs and the lower 4 LSBs. In this regard, the entropy decoder 409 may be configured to initialize probabilities associated with various contexts as starting points for slices of the video. The entropy decoder may be configured to, for example, determine quantization parameters for each slice of the video individually.That is, the entropy decoder 409 may derive information from the data stream 401 on how to set the quantization parameters for each slice. Then, using the slope and offset, a probability estimate is set at the beginning of each slice using the respective quantization parameters of the respective slice. "At the beginning of the slice" may mean, for example, "before decoding the first bin to be entropy decoded using any context". In particular, the entropy decoder 409 may be configured to read the quantization parameters for the current slice from the data stream 401 and initialize the respective probability states associated with the different contexts according to a linear equation of the quantization parameters for the current slice when initializing the respective probability states associated with the different contexts at the beginning of each slice of the video, where the entropy decoder may derive the slope and offset of the linear equation from the first and second 4-bit parts of the same respective 8-bit initialization value for each of the slices. That is, while the quantization parameter QP changes between slices of the video, the pair of slope and offset does not change.

[0240] As mentioned above, the reconstructor 404 may operate in a predictive manner such that, when reconstructing the video 405 based on the integer value of the syntax element 327, the reconstructor 404 may dequantize the transform coefficient levels included in the syntax element using the quantization parameter QP, perform a re-transform on the dequantized transform coefficient levels to obtain a prediction residual, perform spatial and / or temporal prediction to obtain a prediction signal, and further combine the prediction residual and the prediction signal to reconstruct the video 405.

[0241] As a specific example, the entropy decoder 409 may be configured to derive the slope and offset for each of the different contexts from the first and second 4-bit portions independently of each other, for example by table lookup as described above, or alternatively by using separate arithmetic operations such as linear operations. That is, to fill the gap between the 4 bits of the two 4-bit portions of the 8-bit initialization value on the one hand and the 126 different probability state values ​​on the other hand, the entropy decoder 409 may fit both 4-bit portions separately to each linear equation. For example, the MSB p of the 8-bit initialization value is changed to the slope by computing slope=m·p+n, and the 4 LSBs q of the 8-bit initialization value are used to compute the offset by offset=s·q+t, where m, n, t and s are suitably chosen constants. For completeness only, FIG. 17 shows an encoder that matches the decoder of FIG. 16. Here, the encoder of Figure 17 corresponds closely to the structure of, for example, the encoder of Figure 20 or the encoder of other embodiments, just as the decoder of Figure 16 corresponds to the decoder of Figure 11, except for the exclusion of mode switching capability and the implementation of the entropy coder 513 in more comprehensive terms including the PIPE concept or other concepts such as the CABAC concept mentioned above. Besides, all the explanations given with respect to Figure 16 can be transferred equally to Figure 17.

[0242] Although some aspects have been described above in the context of describing an apparatus, it is clear that these aspects are also a description of a corresponding method, and that the blocks or apparatus correspond to method steps or features of a method step. Similarly, aspects described in the context of describing a method step also represent corresponding blocks or items or features of a corresponding apparatus. Some or all of the method steps may be performed by (using) a hardware apparatus, e.g. a microprocessor, a programmable computer, or an electronic circuit. In some embodiments, one or more of the most important method steps may be performed by such an apparatus.

[0243] The encoded signal of the present invention may be stored on a digital storage medium or transmitted over a transmission medium, such as a wireless transmission medium or a wired transmission medium, such as the Internet.

[0244] Depending on certain configuration requirements, embodiments of the present invention can be implemented in hardware or software. This implementation can be performed using a digital storage medium, such as a floppy disk, DVD, Blu-ray, CD, ROM, PROM, EPROM, EEPROM, flash memory, etc., having electronically readable control signals stored therein and cooperating (or capable of cooperating) with a programmable computer system such that the methods of the present invention are performed. Thus, the digital storage medium may be computer readable.

[0245] Some embodiments according to the invention may include a data carrier having electronically readable control signals cooperable with a computer system programmable to carry out one of the methods described above.

[0246] Generally, embodiments of the present invention may be implemented as a computer program product having program code operable to perform one of the methods of the present invention when the computer program product runs on a computer, which program code may for example be stored on a machine readable carrier.

[0247] Other embodiments comprise the computer program stored on a machine readable carrier for performing one of the methods described above.

[0248] In other words, an embodiment of the inventive methods is, therefore, a computer program having a program code for performing one of the above described methods, when the computer program runs on a computer.

[0249] Another embodiment of the invention is a data carrier (or a digital storage medium or a computer readable medium) comprising a computer program recorded thereon for performing one of the methods described above. The data carrier, digital storage medium or recorded medium is typically tangible and / or non-transitory.

[0250] Another embodiment of the invention is also a data stream or a sequence of signals representing the computer program for performing one of the above mentioned methods, which data stream or sequence of signals may be adapted to be transmitted over a data communication connection, for example via the Internet.

[0251] Another embodiment comprises a processing means, for example a computer, or a programmable logic device, configured to or adapted to perform one of the methods described above.

[0252] Another embodiment comprises a computer having installed thereon the computer program for performing one of the methods described above.

[0253] Further embodiments according to the invention include an apparatus or system configured to transfer (e.g. 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, etc. The apparatus or system may for example comprise a file server for transferring the computer program to the receiver.

[0254] In some embodiments, a programmable logic device (such as a field programmable gate array) may be used to perform some or all of the functions of the methods described above. In some embodiments, a field programmable gate array may cooperate with a microprocessor to perform one of the methods described above. In general, such methods may be preferably performed by any hardware apparatus.

[0255] The above-described embodiments are merely illustrative of the principles of the present invention. Modifications and variations in the configurations and details described herein will be apparent to those skilled in the art. Therefore, the present invention should not be limited by the specific details presented herein for purposes of illustrating and explaining the embodiments, but should be limited only by the scope of the appended claims.

[0256] [Claim 1] 1. A decoder for decoding video from a data stream (401) in which a syntax element (327) has been encoded using a binarization of the syntax element, comprising: an entropy decoder (409) for deriving several bins (326) of the binarization from the data stream (401) using binary entropy decoding by selecting one of the different contexts based on a previously decoded portion of the data stream (401) and updating probability states associated with the different contexts; a desymbolizer (314) for de-binarizing the binarization of the syntax elements (327) to obtain integer values ​​of the syntax elements; a reconstruction unit (404) for reconstructing the video using a quantization parameter based on the integer value of the syntax element; the entropy decoder (409) is configured to distinguish between 126 probability states and initialize the probability states associated with the different contexts according to a linear equation of the quantization parameter, the entropy decoder being configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 2] A decoder according to claim 1, The decoder, wherein the entropy decoder (409) is configured to derive a number of bins (326) of the binarization from the data stream (401) using binary arithmetic decoding or binary PIPE decoding. [Claim 3] A decoder according to claim 1 or 2, a bin position of the bin currently to be derived within the binarization to which it belongs; and a syntax element type of the syntax element whose integer value is obtained by debinarizing the binarization to which the bin currently to be derived belongs; in dependence on one or more of: one or more bins previously derived from the data stream (401), or an integer value of a previously de-binarized syntax element; The decoder, wherein the entropy decoder (409) is configured to perform context selection for the currently to-be-derived bin. [Claim 4] A decoder according to any one of claims 1 to 3, the entropy decoder (409) is configured to perform an update of the probability state for the currently derived bin by transitioning from a current probability state associated with a context selected for the currently derived bin among the 126 probability states to a new probability state among the 126 probability states depending on the currently derived bin. [Claim 5] A decoder according to any one of claims 1 to 4, the entropy decoder (409) is configured to obtain a probability interval index by quantizing a current probability interval width value representing a current probability interval, and further to perform an interval subdivision to sub-divide the current probability interval into two sub-intervals by indexing a table entry in a table entry using the probability interval index and a probability state index that depends on a current probability state associated with a context selected for the bin currently to be derived, thereby binary arithmetically decoding the bin currently to be derived. [Claim 6] A decoder according to claim 5, The entropy decoder (409) is configured to use an 8-bit representation for the current probability interval width value and to extract the two or three most significant bits of the 8-bit representation when quantizing the current probability interval width value. [Claim 7] A decoder according to claim 5 or 6, the entropy decoder (409) is configured to select within the two sub-intervals based on an offset state value from within the current probability interval, update the probability interval width value and the offset state value, infer a value of the bin currently to be derived using the selected sub-interval, and perform a renormalization of the updated probability interval width value and the offset state value, including continuing to read bits from the data stream (401). [Claim 8] 8. A decoder according to any of claims 1 to 7, wherein the entropy decoder (409) is configured to initialize probability states associated with the different contexts at the start of a slice of the video. [Claim 9] 9. The decoder of claim 8, wherein the entropy decoder (409) is configured to determine the quantization parameter separately for each slice of the video. [Claim 10] A decoder according to any one of claims 1 to 9, the entropy decoder (409) is configured to initialize probability states associated with the different contexts at a start of a slice of the video by reading the quantization parameter for a current slice from the data stream (401) and initializing the probability states associated with the different contexts according to a linear equation of the quantization parameter for the current slice; the entropy decoder (409) is configured to derive a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each of the same 8-bit initialization values ​​for each of the slices. [Claim 11] A decoder according to any one of claims 1 to 10, the reconstruction unit (404) is configured to, when reconstructing the video (405) based on the integer value of the syntax element (327), dequantize transform coefficient levels included in the syntax element using the quantization parameter, perform a re-transform on the dequantized transform coefficient levels to obtain a prediction residual, perform spatial and / or temporal prediction to obtain a prediction signal, and further combine the prediction residual and the prediction signal to reconstruct the video (405). [Claim 12] A decoder according to any one of claims 1 to 11, the entropy decoder (409) is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value independently of each other. [Claim 13] A decoder according to any one of claims 1 to 12, the entropy decoder is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value using a table lookup or an arithmetic operation. [Claim 14] A decoder according to any one of claims 1 to 12, the entropy decoder is configured to derive, for each of the different contexts, a slope of the linear equation by multiplying and offsetting the first 4-bit portion with a first pair of parameters and to derive an offset of the linear equation by multiplying and offsetting the second 4-bit portion with a second pair of parameters. [Claim 15] 1. An encoder for encoding video into a data stream by encoding syntax elements into the data stream using a binarization of the syntax elements, comprising: a constructor for representing the video by setting integer values ​​of the syntax elements depending on a quantization parameter; a symbolizer for binarizing integer values ​​of the syntax elements to obtain a binarization of the syntax elements; an entropy encoder for encoding some bins of the binarization into the data stream using binary entropy coding by selecting one of different contexts depending on a previously encoded portion of the data stream and updating probability states associated with the different contexts, the entropy encoder is configured to distinguish between 126 probability states and initialize the probability states associated with the different contexts according to a linear equation for the quantization parameter, and the entropy encoder is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of a respective 8-bit initialization value. [Claim 16] 16. The encoder of claim 15, The entropy encoder is configured to encode a number of bins of the binarization into the data stream using binary arithmetic coding or binary PIPE coding. [Claim 17] An encoder according to claim 15 or 16, the bin position of the bin currently to be coded within the binarization to which it belongs; and a syntax element type of the syntax element whose integer value is binarized into the binarization to which the bin currently to be encoded belongs; one or more bins previously coded into the data stream, or integer values ​​of syntax elements whose binarization was previously coded; An encoder, wherein the entropy encoder is configured to perform context selection for the currently to-be-encoded bin. [Claim 18] In the encoder according to any one of claims 15 to 17, the entropy encoder is configured to perform an update of the probability state for the currently encoded bin by transitioning from a current probability state associated with a context selected for the currently encoded bin among the 126 probability states to a new probability state among the 126 probability states depending on the currently encoded bin. [Claim 19] In the encoder according to any one of claims 15 to 18, the entropy encoder is configured to obtain a probability interval index by quantizing a current probability interval width value representing a current probability interval, and further to perform an interval subdivision to sub-divide the current probability interval into two sub-intervals by indexing a table entry in a table entry using the probability interval index and a probability state index that depends on a current probability state associated with a context selected for the bin currently to be encoded, thereby performing binary arithmetic coding of the bin currently to be encoded. [Claim 20] 20. The encoder of claim 19, The entropy encoder is configured to use an 8-bit representation for the current probability interval width value and to extract the two or three most significant bits of the 8-bit representation when quantizing the current probability interval width value. [Claim 21] An encoder according to claim 19 or 20, the entropy encoder is configured to select within the two sub-intervals based on an integer value of the bin currently to be encoded, update the probability interval width value and the probability interval offset using the selected sub-interval, and perform a renormalization of the probability interval width value and the probability interval offset including continually writing bits to the data stream. [Claim 22] An encoder according to any one of claims 15 to 21, The encoder, wherein the entropy decoder is configured to initialize the probability states associated with different contexts at the beginning of each slice of the video. [Claim 23] An encoder according to any one of claims 15 to 22, The entropy encoder is configured to initialize the probability states associated with different contexts at the beginning of each slice of the video. [Claim 24] An encoder according to any one of claims 15 to 23, the entropy encoder is configured to initialize probability states associated with the different contexts at the beginning of each slice of the video by individually setting the quantization parameter for a current slice from the data stream and initializing the probability states associated with the different contexts according to a linear equation of the quantization parameter for the current slice; The entropy encoder is configured to derive a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of a same respective 8-bit initialization value for each of the slices. [Claim 25] An encoder according to any one of claims 15 to 24, The encoder, wherein, when setting the integer value of the syntax element, the construction unit is configured to perform spatial and / or temporal prediction to obtain a prediction signal, derive a prediction residual from the prediction signal and the video, perform a transformation on the prediction residual to obtain transform coefficient levels, and quantize the transform coefficient levels using the quantization parameter to obtain quantized transform coefficient levels included in the syntax element. [Claim 26] An encoder according to any one of claims 15 to 25, the entropy encoder is configured to derive a slope and an offset of the linear equation for each of the different contexts independently from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 27] An encoder according to any one of claims 15 to 26, The entropy encoder is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value using a table lookup or an arithmetic operation. [Claim 28] In the encoder according to any one of claims 15 to 27, the entropy encoder is configured to derive, for each of the different contexts, a slope of the linear equation by multiplying and offsetting the first 4-bit portion with a first pair of parameters and to derive an offset of the linear equation by multiplying and offsetting the second 4-bit portion with a second pair of parameters. [Claim 29] 1. A method for decoding video from a data stream in which a syntax element has been encoded using a binarization of the syntax element, comprising: deriving several bins of the binarization from the data stream using binary entropy decoding by selecting one of the different contexts based on a previously decoded portion of the data stream and updating a probability state associated with the different context; obtaining an integer value of the syntax element by de-binarizing the binarization of the syntax element; and reconstructing the video using a quantization parameter based on the integer value of the syntax element; The step of deriving a number of bins of the binarization distinguishes 126 probability states, the method further comprising initializing probability states associated with the different contexts according to a linear equation of the quantization parameter, and deriving, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 30] 1. A method of encoding video into a data stream by encoding syntax elements into the data stream using a binarization of the syntax elements, comprising: representing the video by setting integer values ​​of the syntax elements in dependence on a quantization parameter; binarizing integer values ​​of the syntax elements to obtain a binarization of the syntax elements; and encoding some bins of the binarization into the data stream using binary entropy coding by selecting one of different contexts depending on a previously encoded portion of the data stream and updating probability states associated with the different contexts, The method, wherein the step of representing the video distinguishes between 126 probability states, the method further comprising initializing probability states associated with the different contexts according to a linear equation for the quantization parameter, and deriving, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 31] A computer program having a program code for performing the method according to claim 29 or 30, when the computer program runs on a computer.

Claims

1. 1. A decoder for decoding video from a data stream (401) in which a syntax element (327) has been encoded using a binarization of the syntax element, comprising: an entropy decoder (409) for deriving several bins (326) of the binarization from the data stream (401) using binary entropy decoding by selecting one of different contexts and updating probability states associated with the different contexts based on previously decoded portions of the data stream (401); a de-symbolizer (314) for de-binarizing the binarization of the syntax elements (327) to obtain integer values ​​of the syntax elements; a reconstruction unit (404) for reconstructing the video using a quantization parameter based on the integer value of the syntax element; the entropy decoder (409) is configured to distinguish between 126 probability states and initialize the probability states associated with the different contexts according to a linear equation of the quantization parameter, the entropy decoder being configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value.

2. 2. A decoder according to claim 1, The entropy decoder (409) is configured to derive a number of bins (326) of the binarization from the data stream (401) using binary arithmetic decoding or binary PIPE decoding.

3. 3. A decoder according to claim 1 or 2, a bin position of the bin currently to be derived within the binarization to which it belongs; and a syntax element type of the syntax element whose integer value is obtained by debinarizing the binarization to which the bin currently to be derived belongs; one or more bins previously derived from the data stream (401), or an integer value of a previously de-binarized syntax element; 4. A decoder, wherein the entropy decoder (409) is configured to perform context selection for the currently to-be-derived bin.

4. A decoder according to any one of claims 1 to 3, the entropy decoder (409) is configured to perform an update of the probability state for the currently derived bin by transitioning from a current probability state associated with a context selected for the currently derived bin among the 126 probability states to a new probability state among the 126 probability states depending on the currently derived bin.

5. A decoder according to any one of claims 1 to 4, the entropy decoder (409) is configured to obtain a probability interval index by quantizing a current probability interval width value representing a current probability interval, and further to perform an interval subdivision to sub-divide the current probability interval into two sub-intervals by indexing a table entry in a table entry using the probability interval index and a probability state index that depends on a current probability state associated with a context selected for the bin currently to be derived, thereby binary arithmetically decoding the bin currently to be derived.

6. 6. A decoder according to claim 5, The entropy decoder (409) is configured to use an 8-bit representation for the current probability interval width value and to extract the two or three most significant bits of the 8-bit representation when quantizing the current probability interval width value.

7. A decoder according to claim 5 or 6, the entropy decoder (409) is configured to select within the two sub-intervals based on an offset state value from within the current probability interval, update the probability interval width value and the offset state value, infer a value of the bin currently to be derived using the selected sub-interval, and perform a renormalization of the updated probability interval width value and the offset state value, including continuing to read bits from the data stream (401).

8. 8. The decoder of any of claims 1 to 7, wherein the entropy decoder (409) is configured to initialize probability states associated with the different contexts at the start of a slice of the video.

9. 9. The decoder of claim 8, wherein the entropy decoder (409) is configured to determine the quantization parameter separately for each slice of the video.

10. A decoder according to any one of claims 1 to 9, the entropy decoder (409) is configured to initialize probability states associated with the different contexts at a start of a slice of the video by reading the quantization parameter for a current slice from the data stream (401) and initializing the probability states associated with the different contexts according to a linear equation of the quantization parameter for the current slice; the entropy decoder (409) is configured to derive a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each same 8-bit initialization value for each of the slices.

11. A decoder according to any one of claims 1 to 10, The reconstruction unit (404) is configured to, when reconstructing the video (405) based on the integer value of the syntax element (327), dequantize the transform coefficient levels included in the syntax element using the quantization parameter, perform a re-transform on the dequantized transform coefficient levels to obtain a prediction residual, perform spatial and / or temporal prediction to obtain a prediction signal, and further combine the prediction residual and the prediction signal to reconstruct the video (405).

12. A decoder according to any one of claims 1 to 11, the entropy decoder (409) is configured to derive, for each of the different contexts, a slope and an offset of the linear equation independently from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value.

13. A decoder according to any one of claims 1 to 12, the entropy decoder is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value using a table lookup or an arithmetic operation.

14. A decoder according to any one of claims 1 to 12, the entropy decoder is configured to derive, for each of the different contexts, a slope of the linear equation by multiplying and offsetting the first 4-bit portion with a first pair of parameters and to derive an offset of the linear equation by multiplying and offsetting the second 4-bit portion with a second pair of parameters.

15. 1. An encoder for encoding video into a data stream by encoding syntax elements into the data stream using a binarization of the syntax elements, comprising: a constructor for representing the video by setting integer values ​​of the syntax elements depending on a quantization parameter; a symbolizer for binarizing integer values ​​of the syntax elements to obtain a binarization of the syntax elements; an entropy encoder for encoding some bins of the binarization into the data stream using binary entropy coding by selecting one of different contexts depending on a previously encoded portion of the data stream and updating probability states associated with the different contexts, the entropy encoder is configured to distinguish between 126 probability states and to initialize the probability states associated with the different contexts according to a linear equation for the quantization parameter, the entropy encoder being configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of a respective 8-bit initialization value.

16. 16. The encoder of claim 15, The entropy coder is configured to code a number of bins of the binarization into the data stream using binary arithmetic coding or binary PIPE coding.

17. 17. An encoder according to claim 15 or 16, the bin position of the bin currently to be coded within the binarization to which it belongs; and a syntax element type of the syntax element whose integer value is binarized into the binarization to which the bin currently to be encoded belongs; one or more bins previously coded into the data stream, or integer values ​​of syntax elements whose binarization was previously coded; An encoder, wherein the entropy encoder is configured to perform context selection for the currently to-be-encoded bin.

18. In the encoder according to any one of claims 15 to 17, The entropy encoder is configured to perform an update of the probability state for a currently encoded bin by transitioning from a current probability state associated with a context selected for the currently encoded bin among the 126 probability states to a new probability state among the 126 probability states depending on the currently encoded bin.

19. In the encoder according to any one of claims 15 to 18, the entropy encoder is configured to obtain a probability interval index by quantizing a current probability interval width value representing a current probability interval, and further to perform an interval subdivision to sub-divide the current probability interval into two sub-intervals by indexing a table entry in a table entry using the probability interval index and a probability state index that depends on a current probability state associated with a context selected for the bin currently to be encoded, thereby performing binary arithmetic coding of the bin currently to be encoded.

20. 20. The encoder of claim 19, The entropy encoder is configured to use an 8-bit representation for the current probability interval width value and to extract the two or three most significant bits of the 8-bit representation when quantizing the current probability interval width value.

21. 21. An encoder according to claim 19 or 20, the entropy encoder is configured to select within the two sub-intervals based on an integer value of the bin currently to be encoded, update the probability interval width value and the probability interval offset using the selected sub-interval, and perform a renormalization of the probability interval width value and the probability interval offset including continually writing bits to the data stream.

22. In the encoder according to any one of claims 15 to 21, The encoder, wherein the entropy decoder is configured to initialize the probability states associated with different contexts at the beginning of each slice of the video.

23. In the encoder according to any one of claims 15 to 22, The entropy encoder is configured to initialize the probability states associated with different contexts at the beginning of each slice of the video.

24. In the encoder according to any one of claims 15 to 23, the entropy encoder is configured to initialize probability states associated with the different contexts at the beginning of each slice of the video by individually setting the quantization parameter for a current slice from the data stream and initializing the probability states associated with the different contexts according to a linear equation of the quantization parameter for the current slice; the entropy encoder is configured to derive a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of a same respective 8-bit initialization value for each of the slices.

25. In the encoder according to any one of claims 15 to 24, The encoder is configured to: when setting the integer value of the syntax element, perform spatial and / or temporal prediction to obtain a prediction signal, derive a prediction residual from the prediction signal and the video, perform a transformation on the prediction residual to obtain transform coefficient levels, and quantize the transform coefficient levels using the quantization parameter to obtain quantized transform coefficient levels included in the syntax element.

26. In the encoder according to any one of claims 15 to 25, the entropy encoder is configured to derive a slope and an offset of the linear equation for each of the different contexts independently from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value.

27. In the encoder according to any one of claims 15 to 26, the entropy encoder is configured to derive, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value using a table lookup or an arithmetic operation.

28. In an encoder according to any one of claims 15 to 27, the entropy encoder is configured to derive, for each of the different contexts, a slope of the linear equation by multiplying and offsetting the first 4-bit portion with a first pair of parameters and to derive an offset of the linear equation by multiplying and offsetting the second 4-bit portion with a second pair of parameters.

29. 1. A method for decoding video from a data stream in which a syntax element has been encoded using a binarization of the syntax element, comprising: - deriving several bins of the binarization from the data stream using binary entropy decoding by selecting one of different contexts based on previously decoded portions of the data stream and updating probability states associated with the different contexts; obtaining an integer value of the syntax element by de-binarizing the binarization of the syntax element; and reconstructing the video using a quantization parameter based on the integer value of the syntax element; The step of deriving a number of bins of the binarization distinguishes 126 probability states, the method further comprising: initializing probability states associated with the different contexts according to a linear equation of the quantization parameter, and deriving, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value.

30. 1. A method of encoding video into a data stream by encoding syntax elements into the data stream using a binarization of the syntax elements, comprising: representing the video by setting integer values ​​of the syntax elements in dependence on a quantization parameter; binarizing integer values ​​of the syntax elements to obtain a binarization of the syntax elements; encoding some bins of the binarization into the data stream using binary entropy coding by selecting one of different contexts depending on a previously encoded portion of the data stream and updating probability states associated with the different contexts, The method of claim 1, wherein the step of representing the video distinguishes between 126 probability states, the method further comprising initializing probability states associated with the different contexts according to a linear equation for the quantization parameter, and deriving, for each of the different contexts, a slope and an offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value.

31. A computer program having a program code for performing the method according to claim 29 or 30, when the computer program is run on a computer.

Images