Context initialization in entropy coding

Abstract

This provides a decoder that further improves the efficiency of adaptive binary entropy coding. [Solution] A decoder that decodes video from a data stream 401 encoded using the binaryization of syntax elements comprises: an entropy decoder 409 that derives several bins of the binaryization from the data stream using binary entropy decoding by selecting one context from among different contexts based on a previously decoded portion of the data stream and updating the probabilistic state associated with the different context; a desymbolizer 314 that obtains integer values ​​of the syntax elements (syntax element sequence 327) by inverse binarizing the binaryization of the syntax elements; and a reconstruction unit 404 that reconstructs video data 405 using quantization parameters based on the integer values ​​of the syntax elements.

Description

[Technical Field]

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

[0002] Numerous video codecs are known in the industry. Generally, these codecs reduce the amount of data required to represent video content; in other words, they compress the data. In entropy coding, it is crucial to encode symbols using probability estimations that correspond as closely as possible to actual symbol statistics. Probability estimation associates a single probability value with each of the possible values ​​that multiple symbols to be encoded may have. For example, in binary entropy coding, symbols have a binary (two-value) nature, and there are only two such possible values. In the case of video coding, the symbols to be encoded belong to various syntax elements that perform various tasks to describe the video context. These include motion vector differences, coding modes, and transformation coefficient levels representing prediction residuals. Firstly, all of these syntax elements have one distinct domain of possible values, and even those syntax elements defined on the same domain of possible values ​​are likely to show different frequency histograms across this domain of possible values. Therefore, the symbols / bins of the symbol strings / bin strings of the symbolization / binaryization of these syntax elements also exhibit different statistics with respect to the probability distribution of the symbol alphabet. Thus, context-adaptive entropy coding is employed. First, different contexts are provided, each associated with a different probability estimate. Therefore, it is likely that, for example, different bins of syntax elements will be assigned to different contexts. Even the spatial relationships between bins / symbols of syntax elements with respect to adjacent parts of an image in a video may be used for selection from the various contexts provided. In this way, it is possible to classify bins / symbols into groups, and the symbol statistics of these groups also change similarly for different video contexts. However, beyond that, the probability estimates associated with these contexts are continuously adapted to the actual symbol statistics during coding.

[0003] From the above explanation, it is immediately clear that it is important to carefully design the contexts and to appropriately initialize the probability estimates of the contexts. For example, if the number of contexts is too large, the adaptation of the probability estimates will fail because the frequency of occurrence of each symbol within each context will be too low. On the other hand, if the number of contexts is too small, the symbols collected within each context will have practically different statistics, so it will be impossible for the probability estimates to exactly approximate the actual symbol statistics of all these symbols within each context. As far as the initialization of the probability estimates is concerned, this initialization may be obtained by performing a practice stage in which a representative blend of video content is encoded and the sample statistics of syntax elements are studied. In this case, for example, in H.264, it has been taken advantage of the fact that the symbol statistics of symbols in various H.264 content partially show a dependency on the quantization parameter QP that the encoder selects for each slice of video. In other words, in H.264, 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. In other words, there was a factor that depended on the linear quantization parameter, namely the slope, and an offset value, namely an initialization value independent of the quantization parameter. Both values ​​were defined using 8 bits.

[0004] There is a constant demand for further improvements in the encoding efficiency of video coding. Therefore, it would be desirable if the aforementioned context-adaptive binary entropy coding could be further improved in terms of efficiency, that is, if it could be improved at a compromise between compression ratio and implementation complexity. [Prior art documents] [Patent Documents]

[0005] [Patent Document 1] WO2011 / 128268A1 [Overview of the project]

Problems to be Solved by the Invention

[0006] Therefore, an object of the present invention is to provide a coating concept as described above.

Means for Solving the Problems

[0007] This object is achieved by the gist of the appended independent claims.

[0008] The basic finding of the present invention is based on the following discovery by the inventors. That is, the accuracy of the above-described slope and offset in context-adaptive binary entropy coding should not be too high, because any training stage in which a representative blend of video content is examined to derive a pair of slope and offset for each individual context would actually approximate the blend of video content examined more closely than the representative value of the statistical population of the video, in order to avoid sticking to an optimal value. Therefore, the inventors of the present invention have discovered that it is preferable to reduce the accuracy of providing values of slope and offset in order to initialize the probability estimation of the context. The inventors have realized that such a reduction not only results in a reduction in the memory requirements imposed on the video encoder and decoder for storing, for example, pairs of slope and offset, but also slightly improves the coding efficiency when testing the coding efficiency in the field.

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

Brief Description of the Drawings

[0010] [Figure 1] A block diagram of an encoder according to an embodiment is shown. [Figure 2] 2A to 2C schematically show various sub-divisions from a sample array such as a picture into blocks. [Figure 3] A block diagram of a decoder according to an embodiment is shown. [Figure 4] The block diagram of an encoder according to an embodiment is shown in more detail. [Figure 5] The block diagram of a decoder according to an embodiment is shown in more detail. [Figure 6] The conversion from the spatial domain of a block to the spectral domain, and the resulting conversion block and its reconversion are schematically shown. [Figure 7] The block diagram of an encoder according to an embodiment is shown. [Figure 8] The block diagram of a decoder according to an embodiment suitable for decoding the bitstream generated by the encoder of FIG. 8 is shown. [Figure 9] A schematic diagram showing a data packet according to an embodiment having a multiplexed partial bitstream is shown. [Figure 10] A schematic diagram showing a data packet according to another embodiment having another segmentation using fixed-size segments is shown. [Figure 11] A decoder according to an embodiment supporting mode switching is shown. [Figure 12] A decoder according to another embodiment supporting mode switching is shown. [Figure 13] An encoder according to an embodiment adapted to the decoder of FIG. 11 is shown. [Figure 14] An encoder according to an embodiment adapted to the decoder of FIG. 12 is shown. [Figure 15] The mapping between pStateCtx and fullCtxState / 256 is shown. [Figure 16] A decoder according to an embodiment of the present invention is shown. [Figure 17] An encoder according to an embodiment of the present invention is shown.

Mode for Carrying Out the Invention

[0011] In describing the figures, components appearing in some of these figures are indicated by the same reference numerals in each of those figures, and to avoid unnecessary repetition, repeated explanations of those components are omitted as far as their function is concerned. However, the function and description given for one drawing shall apply to other drawings unless explicitly stated otherwise.

[0012] Below, embodiments of the overall video coding concept are first described with reference to Figures 1 to 17. Figures 1 to 6 relate to the video codec portion that operates at the syntax level. Figures 8 to 17 then relate to embodiments of the coding portion relating to the conversion from a syntax element stream to a data stream and vice versa. Next, specific aspects and embodiments of the present invention are described as possible embodiments of the overall concept described with reference to Figures 1 to 17.

[0013] Figure 1 shows an example of an encoder 10 in which various embodiments of the present invention can 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, and chroma values. However, the information samples may also be depth values ​​if the sample array 20 is a depth map generated, for example, by the time of a light sensor.

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

[0016] Furthermore, the encoder 10 is a transform encoder. That is, the encoder 10 encodes the blocks 40 by using a transform to move the information samples within each block 40 from the spatial domain to the spectral domain. A two-dimensional transform, such as a DCT of the FFT, may be used. Preferably, the blocks 40 are square or rectangular.

[0017] The subdivision of the sample array 20 into blocks 40 shown in Figure 1 is for illustrative purposes only. Figure 1 shows the sample array 20 as it has been subdivisioned into a regular two-dimensional arrangement of adjacent square or rectangular blocks 40 that do not overlap. The size of the blocks 40 may be predetermined. That is, the encoder 10 does not need to transmit information about the block size of the blocks 40 to the decoder in the data stream 30. For example, the decoder may anticipate its predetermined block size.

[0018] However, several alternatives are possible. For example, blocks may overlap each other. However, the degree of overlap is limited such that each block has a portion that does not overlap any adjacent block, or that each sample of a block overlaps with at most one adjacent block that is placed alongside the current block along a given direction. The latter means that adjacent blocks to the left and right may overlap to completely cover the current block, but the adjacent blocks themselves do not overlap each other. The same applies to adjacency in the vertical and diagonal directions.

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

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

[0021] Instead of a quadtree-based subpartition, a more general double-tree-based subpartition may be used, and the number of child nodes per hierarchy level may differ between different hierarchy levels.

[0022] Figure 2b shows another example of subdivision. According to Figure 2b, the sample array 20 is first divided into macroblocks 40b in a regular two-dimensional arrangement, adjacent to each other without overlapping. Here, each microblock 40b is associated with subdivision information, which divides the microblock into subblocks of the same size in a regular two-dimensional manner, such that the microblock is either not subdivided or, if subdivided, different subdivision granularities are achieved for different microblocks. The result is a subdivision of the sample array 20 into blocks 40 of different sizes, representative examples of different sizes are shown in 40a, 40b, and 40a'. As shown in Figure 2a, the encoder 10 performs a two-dimensional transformation on each of the blocks shown by solid and dashed lines in Figure 2b. Figure 2c will be discussed later.

[0023] Figure 3 shows a decoder 50 that can decode the data stream 30 generated by the encoder 10 to reconstruct a restored version 60 of the sample array 20. The decoder 50 reconstructs the restored version 60 by extracting a transformation coefficient block for each of the blocks 40 from the data stream 30 and performing an inverse transformation on each of the transformation coefficient blocks.

[0024] The encoder 10 and decoder 50 may be configured to perform entropy coding / decoding, respectively, to insert information about the conversion coefficient blocks and to extract this information from the data stream. Details regarding this will be described later. Note that the data stream 30 does not necessarily have to contain information about the conversion coefficient blocks for all blocks 40 of the sample array 20. Rather, a subset of blocks 40 may be coded into the bitstream 30 by other methods. For example, the encoder 10 may decide not to insert the conversion coefficient block for a certain block of block 40, and instead insert alternative coding parameters into the bitstream 30 so that the decoder 50 can predict them or fill each block in the restored version 60. For example, the encoder 10 may perform texture analysis to arrange blocks in the sample array 20 so that the decoder can perform texture synthesis on the decoding side to fill the sample array 20, and then appropriately indicate this in the bitstream.

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

[0026] The coder in Figure 4 is a predictive transform-based block coder. That is, a block of sample array 20 entering input 112 is predicted from a previously encoded and reconstructed portion of the same sample array 20, or from another previously encoded and reconstructed sample array that may precede or follow the current sample array 20 in performance time. The prediction is performed by the predictor 106. The subtractor 108 subtracts the predicted value from such an original block, and the transform stage 100 performs a two-dimensional transform on the prediction residue. The two-dimensional transform itself or subsequent processing within the transform stage 100 may lead to the quantization of the transform coefficients in the transform coefficient block. The quantized transform coefficient block is losslessly encoded by entropy coding, for example, in the entropy encoder 102, and the resulting data stream is output at output 114. The inverse transform stage 104 reconstructs the quantized residue, and the subsequent adder 110 obtains a reconstructed information sample by combining the reconstructed residue with the corresponding prediction. Based on this information sample, the predictor 106 can predict the currently encoded prediction block described above. The predictor 106 may use different prediction modes, such as intra-prediction mode and inter-prediction mode, to predict the block, and the prediction parameters are sent to the entropy encoder 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 encoder 114 so that the decoder can reproduce the prediction. The motion data for the picture prediction block may include a syntax portion containing a syntax element representing a motion vector difference, which may differentially encode the motion vector for the current prediction block by comparing it with a motion vector prediction value derived in a predetermined way, for example, from the motion vectors of neighboring already encoded prediction blocks.

[0027] That is, according to the embodiment of Figure 4, the transformation coefficient block represents the spectral representation of the residual of the sample array, rather than the actual information samples of the sample array. That is, according to the embodiment of Figure 4, the 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 transformation block, a syntax element of the motion vector difference for the interprediction block, a significance map indicating the location of the significance transformation coefficient level, and a syntax element defining the significance transformation coefficient level itself.

[0028] Note that there are several alternative embodiments to the one shown in Figure 4, some of which are described in the introduction of the specification, and these descriptions are incorporated here into the explanation of Figure 4.

[0029] Figure 5 shows a decoder capable of decoding the data stream generated by the encoder in Figure 4. The decoder in 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 this order in series between the input 158 ​​and the output 160 of the decoder in Figure 5. The other output of the entropy decoder 150 is connected to the predictor 156, which is then connected between the output of the adder 154 and its other inputs. The entropy decoder 150 extracts a transformation coefficient block from the data stream entering the decoder in Figure 5 at input 158, in which case an inverse transform is applied to the transformation coefficient block in stage 152 to obtain a residual signal. The residual signal is combined with the prediction from the predictor 156 in adder 154 to obtain a reconstructed block, which is a reconfigured version of the sample array at output 160. Based on the reconstructed version, the predictor 156 generates a prediction, thereby reconstructing the prediction made by the predictor 106 on the encoder side. To obtain the same prediction used on the encoder side, the predictor 156 uses prediction parameters, which are obtained by the entropy decoder 150 from the data stream at input 158.

[0030] In the above embodiment, the spatial granularity at which residual prediction and transformation are performed does not have to be equal to each other. This is shown in Figure 2C, where the subdivisions of the prediction blocks are shown as solid lines and the residual granularity as dashed lines. As can be seen from the figure, the subdivisions may be selected by mutually independent encoders. More precisely, the syntax of the data stream allows for the definition of residual subdivisions independent of the prediction subdivisions. Alternatively, the residual subdivisions may be an extension of the prediction subdivisions, where each residual block is equal to or an appropriate subset of the prediction blocks. This is shown, for example, in Figures 2a and 2b, where again, the prediction granularity is shown as solid lines and the residual granularity as dashed lines. In other words, in Figures 2a to 2c, all blocks with reference numerals are residual blocks on which one two-dimensional transformation is performed, while the larger solid block containing the dashed block 40a is a prediction block on which, for example, prediction parameter settings are performed individually.

[0031] The embodiments described above share the common feature that a block of (residual or original) samples is transformed into a transformation coefficient block on the encoder side, and that this transformation coefficient block is then transformed back into a reconfigured block of samples on the decoder side. This is illustrated in Figure 6. Figure 6 shows a block of sample 200. In Figure 6, this block 200 is, exemplarily, a two-dimensional sample 202 of size 4·4. Samples 202 are regularly arranged along the horizontal x and vertical y directions. The two-dimensional transformation T described above transforms block 200 into a block 204 of spectral domains, i.e., transformation coefficients 206, where the transformed block 204 is the same size as block 200. That is, the transformed block 204 has the same number of transformation coefficients 206 as the number of samples in block 200, both horizontally and vertically. However, since the transformation T is a spectral transformation, the positions of the transformation coefficients 206 within the transformed block 204 correspond to spectral components, not the spatial positions of the contents of block 200. In particular, the horizontal axis of the transformation 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. Here, the DC component transformation coefficients are located at the corners of block 204, in this example at the top left corner, such that the transformation coefficient 206 corresponding to the highest frequency in both the horizontal and vertical directions is located at the bottom right corner. If the spatial direction is ignored, the spatial frequency to which a given transformation coefficient 206 belongs generally increases from the top left corner to the bottom right corner. Inverse transformation T -1 As a result, the transformed block 204 is retransmitted from the spectral domain to the spatial domain, thereby reacquiring a copy 208 of block 200. If no quantization / loss occurs during the transformation, the reconstruction is complete.

[0032] As already mentioned above, Figure 6 shows that increasing the block size of block 200 increases the spectral resolution of the resulting spectral display 204. On the other hand, quantization noise tends to spread throughout block 208, and therefore, abrupt and very local objects within block 200 tend to cause deviations in the re-transformed block compared to the original block 200 due to quantization noise. However, the main advantage of using larger blocks is that, compared to smaller blocks, the ratio of significant, i.e., non-zero (quantized) transformation coefficients, i.e., levels, to the number of non-significant transformation coefficients can be reduced within larger blocks, resulting in better encoding efficiency. In other words, significant transformation coefficient levels, i.e., transformation coefficient levels that have not been quantized to zero, are often sparsely distributed across the transformed block 204. Therefore, according to embodiments described in more detail below, the location of significant transformation coefficient levels is signaled within the data stream by a significance map. Separately, the value of the significance transformation coefficient, i.e., the transformation coefficient level if the transformation coefficient is quantized, is transmitted within the data stream.

[0033] Therefore, all the encoders and decoders described above are configured to handle a predetermined syntax of syntax elements. That is, the syntax elements described above, such as the transformation coefficient levels, the significance maps of the transformation blocks, and the motion data syntax elements for the interpretation blocks, are assumed to be arranged sequentially in the data stream in a predetermined manner. Such a predetermined manner may be expressed in the form of pseudocode, for example, as done in the H264 standard or other video codecs.

[0034] To put it another way, the above description primarily deals with the conversion from media data, which is video data in this example, to a sequence of syntax elements that conforms to a predefined syntax structure defining a given type of syntax element, as well as its semantics and the order between them. The entropy encoder and entropy decoder in Figures 4 and 5 may operate and be configured as described below. These encoders and decoders are responsible for performing the conversion between the sequence of syntax elements and the data stream, i.e., the stream of symbols or bits.

[0035] Figure 7 shows an entropy encoder according to an embodiment of the present invention. This encoder losslessly converts a stream 301 of syntax elements 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 category of a set of syntax element types. For example, a category can identify the type of syntax element. In the context of hybrid video coding, separate categories may be associated with macroblock coding modes, block coding modes, reference picture index, motion vector difference, sub-partition flags, coded block flags, quantization parameters, transformation coefficient levels, etc. Various classifications of syntax elements are possible in other application areas such as audio, speech, text, documents, or general-purpose data coding.

[0037] Generally, each syntax element can take on a finite or countably infinite set of values, where the set of possible syntax element values ​​can differ for each different syntax element category. For example, both binary and integer syntax elements exist.

[0038] To reduce the complexity of encoding and decoding algorithms and to enable the design of general encoding and decoding for various syntax elements and syntax element categories, syntax elements 301 are transformed into an ordered set of binary decisions, which are then processed by a simple binary encoding algorithm. Thus, the binaryizer 302 bijectively maps the value of each syntax element 301 to a sequence (or string or word) of bins 303. A sequence of bins 303 represents a set of ordered binary decisions. Each bin 303 or binary decision can take one value from a set of two values, for example, either value 0 or 1. The binaryization scheme may differ for different syntax element categories. The binaryization scheme for a particular syntax element category may depend on the set of possible syntax element values ​​for that particular category and / or other properties of the syntax element.

[0039] Table 1 shows three exemplary binaryization schemes for countably infinite sets. These binaryization 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 inefficiencies (resulting from unused bin sequences) can be ignored, but the universality of such binaryization schemes offers advantages in terms of complexity and memory requirements. For small finite sets of syntax element values, it is often preferable (from the standpoint of coding efficiency) to adapt the binaryization scheme to the number of possible symbol values.

[0040] Table 2 shows three exemplary binaryization schemes for a finite set of eight values. Binaryization schemes for finite sets can be derived from universal binaryization schemes for countably infinite sets by modifying some of the bin sequences so that a finite set of bin sequences represents a sign without redundancy (and potentially rearranges the bin sequences). For example, the truncated unary binaryization scheme in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal unary binaryization (see Table 1). The truncated and rearranged exponential Golomb binaryization of degree 0 in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal exponential Golomb degree 0 (see Table 1) and by rearranging 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 binaryization schemes, as illustrated in the last column of Table 2.

[0041] [Table 1]

[0042] [Table 2]

[0043] Each bin 303 in the bin sequence created by the binaryr 302 is sequentially sent to the parameter assignment unit 304. The parameter assignment unit assigns a set of one or more parameters to each bin 303 and outputs a bin 305 having the associated set of parameters. The set of parameters is determined in exactly the same way in the encoder and decoder. The set of parameters may consist of one or more of the following parameters:

[0044] In particular, the parameter assignment unit 304 may be configured to assign a context model to the current bin 303. For example, the parameter assignment unit 304 may select one of the valid context indices for the current bin 303. The set of valid contexts for the current bin 303 may depend on the type of bin, which may be defined by the type / category of the syntax element 301, the bination to which the current bin 303 is a part, and the position of the current bin 303 within that bination. The selection of a context from the set of valid contexts may depend on a previous bin and the syntax elements associated with that bin. Each of these contexts has a probabilistic model associated with it; that is, it has a measure of probability estimation for one of two possible bin values ​​for the current bin. The probabilistic model may, in particular, be a measure of probability estimation for a bin value that has a disadvantageous or superior probability for the current bin, and further, the probabilistic model may be defined by an identifier that specifies the estimation of which of the two possible bin values ​​represents the disadvantageous or superior bin value for the current bin 303. If only one context is valid for the current bin, context selection is not required. As will be explained in more detail later, the parameter assignment unit 304 may perform adaptation of the probabilistic model to adapt the probabilistic model associated with different contexts to the actual bin statistics of each bin belonging to each context.

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

[0046] Each bin 305, which has an associated set of parameters that are the output of the parameter assignment unit 304, is sent to the bin buffer selection unit 306. The bin buffer selection unit 306 potentially modifies the value of the input bin 305 based on the input bin value and its associated parameter 305, and sends the output bin 307 (which has the 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 parameter 305.

[0047] In a preferred embodiment of the present invention, the bin buffer selection unit 306 does not change the bin value; that is, 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 selection unit 306 determines the output bin value 307 based on the input bin value 305 and an associated scale for probability estimation of one of two possible bin values ​​for the current bin. In a preferred embodiment of the present invention, the output bin value 307 is set to be equivalent to the input bin value 305 if the probability scale for one of the two possible bin values ​​for the current bin is less than (or less than or equal to) a certain threshold; on the other hand, if the probability scale for one of the two possible bin values ​​for the current bin is greater than (or equal to) a certain threshold, the output bin value 307 is changed (i.e., set to the opposite of the input bin value). In a further preferred embodiment of the present invention, the output bin value 307 is set to a value equal to the input bin value 305 if the probability scale for one of the two possible bin values ​​for the current bin is greater than (or equal to) a certain threshold, while the output bin value 307 is changed (i.e., set to the reverse of the input bin value) if the probability scale 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 present 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 selection unit 306 determines an output bin value 307 based on an input bin value 305 and an associated identifier that specifies an estimation of which of two possible bin values ​​represents a bin value with respect to the current bin that has a disadvantageous or superior probability. In a preferred embodiment of the present invention, if the identifier specifies that the first of the two possible bin values ​​represents a bin value with respect to the current bin that has a disadvantageous (or superior) probability, the output bin value 307 is set to a value equal to the input bin value 305; on the other hand, if the identifier specifies that the second of the two possible bin values ​​represents a bin value with respect to the current bin that has a disadvantageous (or superior) probability, the output bin value 307 is changed (i.e., set to the opposite of the input bin value).

[0049] In a preferred embodiment of the present invention, the bin buffer selection unit 306 determines the bin buffer 308 to which the output bin 307 is sent based on a scale associated for probability estimation for one of two possible bin values ​​for the current bin. In a preferred embodiment of the present invention, the set of possible values ​​as the scale for probability estimation for one of two possible bin values ​​is finite, and the bin buffer selection unit 306 includes a table associating a positive one bin buffer 308 for each possible value for probability estimation for one of two possible bin values, in which different values ​​of the scale for probability estimation for one of two possible bin values ​​can be associated with the same bin buffer 308. In a further preferred embodiment of the present invention, the range of possible values ​​as a measure of probability estimation for one of two possible bin values ​​is divided into several intervals, and the bin buffer selection unit 306 determines an interval index for the current measure of probability estimation for one of the two possible bin values, and further, the bin buffer selection unit 306 includes a table that associates a positive bin buffer 308 with each possible value for this interval index, where different values ​​for the interval index can be associated with the same bin buffer 308. In a preferred embodiment of the present invention, an input bin 305 having an inverse measure of probability estimation for one of the two possible bin values ​​(where the inverse measure is a measure representing probability estimates P and 1-P) is supplied to the same bin buffer 308. In a further preferred embodiment of the present invention, associating a measure of probability estimation for one of the two possible bin values ​​with a particular bin buffer is adapted over time, for example, to ensure that the resulting partial bitstreams have similar bit rates. In the following, the interval index is also called the pipe index, and this pipe index, along with the refinement index and a flag indicating the dominant bin value, indicates the actual probability model, i.e., the probability estimation.

[0050] In a preferred embodiment of the present invention, the bin buffer selection unit 306 determines which bin buffer 308 to send the output bin 307 to based on a measure associated with the probability estimation of a bin value that has a disadvantageous or superior probability with respect to the current bin. In a preferred embodiment of the present invention, the set of possible values ​​for the measure for the probability estimation of a bin value that has a disadvantageous or superior probability is finite, and the bin buffer selection unit 306 includes a table that associates exactly one bin buffer 308 with each possible value for the probability estimation of a bin value that has a disadvantageous or superior probability, in which different values ​​for the measure for the probability estimation of a bin value that has a disadvantageous or superior probability can be associated with the same bin buffer 308. In a further preferred embodiment of the present invention, the range of possible values ​​as a measure of probability estimation for bin values ​​having inferior or superior probabilities is divided into several intervals, the bin buffer selection unit 306 determines an interval index with respect to the current measure for probability estimation for bin values ​​having inferior or superior probabilities, and further, the bin buffer selection unit 306 includes a table that associates one bin buffer 308 with each possible value for this interval index, in which different values ​​for the interval index can be associated with the same bin buffer 308. In a further embodiment of the present invention, associating a measure of probability estimation for bin values ​​having inferior or superior probabilities with respect to the current bin with a particular bin buffer is adapted over time, for example, to ensure that the resulting partial bitstreams have similar bit rates.

[0051] Each of 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 its associated bin buffer 308 and converts the bin sequence 309 into a codeword 311 representing a bit sequence. The bin buffers 308 represent first-in, first-out buffers; that is, bins sent to the bin buffer 308 later (in order) will not be encoded before bins sent to the bin buffer 308 earlier (in order). The codeword 311, which is the output of a particular bin encoder 310, is written to a particular partial bitstream 312. The overall encoding algorithm converts syntax elements 301 into two or more partial bitstreams 312, in which case 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 bin coding can be performed in parallel (for example, for each group with a different probability scale), which reduces processing time in some configurations.

[0052] Another advantage of embodiments of the present invention is that the bin coding performed by the bin encoder 310 can be specifically designed for various sets of parameters 305. In particular, the bin coding and coding can be optimized (with respect to coding efficiency and / or complexity) for each different group of estimated probabilities. On the one hand, this advantage allows for a reduction in coding / decoding complexity. On the other hand, it allows for an improvement in coding efficiency. In one preferred embodiment of the present invention, the bin encoder 310 implements a different coding algorithm (i.e., mapping of bin sequences to codewords) for each different group of probability estimates for one of two possible bin values ​​5 with respect to the current bin. In a further preferred embodiment of the present invention, the bin encoder 310 implements a different coding algorithm for each different group of probability estimates for bin values ​​that have inferior or superior probabilities with respect to the current bin.

[0053] In a preferred embodiment of the present invention, the plurality of bin encoders 310—or one or more bin encoders—represent an entropy encoder that directly maps an input bin sequence 309 to a codeword 311. Such mapping can be performed efficiently and does not require a complex arithmetic coding engine. While the reverse mapping of a codeword to a bin sequence (as done in a decoder) needs to be unique to ensure complete decoding of the input sequence, the mapping of a bin sequence 309 to a codeword 311 does not necessarily need to be unique. That is, one particular bin sequence can be mapped to a sequence of two or more codewords. In a preferred embodiment of the present invention, the mapping of an input bin sequence 309 to a codeword 311 is bijective. In a further preferred embodiment of the present invention, the plurality of bin encoders 310—or one or more bin encoders—represent an entropy encoder that directly maps a variable-length input bin sequence 309 to a variable-length codeword 311. In a preferred embodiment of the present invention, the output codeword represents a code without redundancy, such as general Huffman codes or canonical Huffman codes.

[0054] Table 3 shows two examples of bijectively mapping a bin sequence to a code without redundancy. In a further preferred embodiment of the present invention, the output codeword represents a code with redundancy suitable for error detection and error recovery. In a further preferred embodiment of the present invention, the output codeword represents an encryption code suitable for encrypting a syntax element.

[0055] [Table 3]

[0056] In a further preferred embodiment of the present invention, the plurality of bin encoders 310—or one or more bin encoders—represent an entropy encoder that directly maps a variable-length input bin sequence 309 to a fixed-length codeword 311.

[0057] Figure 8 shows a decoder according to one embodiment of the present invention. This decoder essentially performs the reverse operation of the encoder described above, thereby decoding a sequence of (previously encoded) syntax elements 327 from a set 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 reverse of the encoder data flow. In Figure 8, dashed arrows represent the data request flow, while solid arrows represent the data flow. The decoder's constituent blocks essentially replicate those of the encoder, but perform the reverse operation.

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

[0059] The binaryr 314 maps the request 313 for the syntax element to one or more requests for bins, which are sent to the parameter assignment unit 316. As a final response to the requests for bins sent by the binaryr 314 to the parameter assignment unit 316, the binaryr 314 receives the decoded bins 326 from the bin buffer selection unit 318. The binaryr 314 compares the received sequence of decoded bins 326 with the sequence of bins for a specific binaryization scheme for the requested syntax element. If the received sequence of decoded bins 326 matches the binaryization of the syntax element, the binaryr empties its bin buffer and outputs the decoded syntax element as a final response to a request for a new decoded symbol. If the sequence of decoded bins already received does not match any of the bin sequences of the binaryization scheme for the requested syntax element, the binaryizer sends other requests for bins to the parameter assignment unit until the sequence of decoded bins matches one of the bin sequences of the binaryization scheme for the requested syntax element. For each request for a syntax element, the decoder uses the same binaryization scheme that was used to encode the corresponding syntax element. The binaryization scheme may differ for different syntax element categories. The binaryization scheme for a particular syntax element category may depend on the set of possible syntax element values ​​and / or other properties of the syntax element for a particular category.

[0060] The parameter assignment unit 316 assigns one or more sets of parameters to each request for a bin, and then transmits the request for that bin and the set of parameters associated with it to the bin buffer selection unit. The set of parameters assigned by the parameter assignment unit to the requested bin is the same as the set assigned to the corresponding bin during the encoding process. This set of parameters may consist of one or more of the parameters described above in the encoder description in Figure 7.

[0061] In a preferred embodiment of the present invention, the parameter assignment unit 316 associates each request for a bin with parameters similar to those performed by the assignment unit 304, namely, the context and its associated measures, which are measures of probability estimation for one of two possible bin values ​​with respect to the currently requested bin, such as measures of probability estimation for bin values ​​that have a disadvantageous or superior probability with respect to the currently requested bin, or identifiers that specify which of the two possible bin values ​​represents the bin value that has a disadvantageous or superior probability with respect to the currently requested bin.

[0062] The parameter assignment unit 316 may determine one or more of the probability measures described above (a probability estimate for one of two possible bin values ​​for the currently requested bin, a probability estimate for a bin value that has a lower or higher probability for the currently requested bin, and an identifier that specifies which of the two possible bin values ​​represents the bin value that has a lower or higher probability for the currently requested bin) based on one or more sets of already decoded symbols. Determining 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 scale may include one or more already decoded symbols of the same symbol category, one or more already decoded symbols of the same symbol category corresponding to data sets (such as blocks or groups of samples) that are spatially and / or temporally adjacent (to the data set associated with the current request for the syntax element), or one or more already decoded symbols of different symbol categories corresponding to data sets that are spatially and / or temporally identical and / or adjacent (to the data set associated with the current request for the syntax element).

[0063] Each request 317 for a bin having a set of associated parameters, which is the output of the parameter assignment unit 316, is sent into the bin buffer selection unit 318. Based on the set of associated parameters 317, the bin buffer selection unit 318 sends a request 319 for a bin to 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 the decoded output bin 326—which has a potentially modified value—is sent to the binaryr 314 as the final response to the request 317 for a bin having a set of associated parameters.

[0064] The method by which the bin buffer 320 to which a request for a bin should be sent is the same as the method by which the bin buffer to which the output bin of the bin buffer selection unit should be sent is selected on the encoder side.

[0065] In a preferred embodiment of the present invention, the bin buffer selection unit 318 determines the bin buffer 320 to which a request for a bin 319 should be sent, based on an associated measure of a probability estimate for one of 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 a probability estimate for one of two possible bin values ​​is finite, and the bin buffer selection unit 318 includes a table that associates a positive bin buffer 320 with each possible value of the probability estimate for one of two possible bin values, where different values ​​for the measure of a probability estimate for one of 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 a scale of probability estimation for one of two possible bin values ​​is divided into a plurality of intervals, the bin buffer selection unit 318 determines the interval index for the current scale of probability estimation for one of the two possible bin values, and further, the bin buffer selection unit 318 includes a table that associates a positive bin buffer 320 with each possible value for the interval index, where different values ​​for the interval index can be associated with the same bin buffer 320. In a preferred embodiment of the present invention, with respect to a probability estimation for one of two possible bin values, a request 317 for a bin having an opposite scale (opposite scales being scales representing probability estimation P and 1-P) may be transferred to the same bin buffer 320. In a further preferred embodiment of the present invention, the association between a scale of probability estimation for one of two possible bin values ​​and a specific bin buffer with respect to the current bin request may be adapted over time.

[0066] In a further preferred embodiment of the present invention, the bin buffer selection unit 318 may determine the bin buffer 320 to which the request for a bin 319 should be sent based on an associated measure of probability estimation for a bin value having a disadvantageous or superior probability for the currently requested bin. In a preferred embodiment of the present invention, the set of possible values ​​for the measure of probability estimation for a bin value having a disadvantageous or superior probability is finite, and the bin buffer selection unit 318 includes a table that associates each possible value of the probability estimation for a bin value having a disadvantageous or superior probability with exactly one bin buffer 320, where different values ​​of the measure of probability estimation for a bin value having a disadvantageous 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 a probability estimation scale for bin values ​​having inferior or superior probabilities is divided into a plurality of intervals, and the bin buffer selection unit 318 determines the interval index for the current scale for probability estimation for bin values ​​having inferior or superior probabilities, and further, the bin buffer selection unit 318 includes a table that associates exactly one bin buffer 320 with each possible value for the interval index, where different values ​​for the interval index can be associated with the same bin buffer 320. In a further preferred embodiment of the present invention, the association between a probability estimation scale for bin values ​​having inferior or superior probabilities with respect to the currently requested bin and a specific bin buffer is adapted over time.

[0067] The bin buffer selection unit 318 receives the decoded bin 325 from the selected bin buffer 320, then potentially modifies the input bin 325 and sends the output bin 326—which has the potentially modified value—to the binaryr 314. The input / output bin mapping of the bin buffer selection unit 318 is the reverse of the input / output bin mapping of the bin buffer selection unit on the encoder side.

[0068] In one preferred embodiment of the present invention, the bin buffer selection unit 318 is configured not to change the bin value, 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 selection unit 318 determines the output bin value 326 based on the input bin value 325 and a measure of probability estimation for one of two possible bin values ​​for the currently requested bin associated with the bin request 317. In one 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 less than (or less than or equal to) a certain threshold, the output bin value 326 is set to be equal to the input bin value 325; on the other hand, if the measure of probability for one of the two possible bin values ​​for the current bin request is greater than (or equal to) a certain threshold, the output bin value 326 is changed (i.e., set to the reverse of the input bin value). In a preferred further embodiment of the present invention, the output bin value 326 is set to be equal to the input bin value 325 if the probability scale for one of the two possible bin values ​​for the current bin request is greater than (or equal to) a certain threshold, but if the probability scale for one of the two possible bin values ​​for the current bin request is less than (or equal to) a certain threshold, the output bin value 326 is changed (i.e., set to the reverse of the input bin value). In a preferred embodiment of the present invention, the threshold corresponds to a value of 0.5 with respect to the estimated probabilities for both possible bin values.

[0069] In a further preferred embodiment of the present invention, the bin buffer selection unit 318 determines an output bin value 326 based on an input bin value 325 and an identifier associated with a bin request 317, which specifies an estimate of which of two possible bin values ​​represents a bin value with a disadvantageous or superior probability with respect to 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 a bin value with a disadvantageous (or superior) probability with respect to the current bin request, the output bin value 326 is set to be equal to the input bin value 325; on the other hand, if the identifier specifies that the second of the two possible bin values ​​represents a bin value with a disadvantageous (or superior) probability with respect to the current bin request, the output bin value 326 is changed (i.e., set to the opposite of the input bin value).

[0070] As described above, the bin buffer selection unit sends a request 319 for a bin 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 the connected bin decoder 322. In response to the request 319 for a bin sent from the bin buffer selection unit 318 to the bin buffer 320, the bin buffer 320 removes the bin whose content was first sent to the bin buffer 320 and sends it to the bin buffer selection unit 318. Bins that are sent to the bin buffer 320 first are removed first and sent to the bin buffer selection unit 318.

[0071] Each of 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 are sent to the connected bin buffers 320. The overall decoding algorithm converts two or more partial bitstreams 324 into a plurality 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 syntax elements is triggered by requests for new syntax elements. In a preferred embodiment of the present invention, the bin decoder 322 converts a codeword 323 consisting of a variable number of bits into a sequence of bins 321 of a variable number. One advantage of the embodiments of the present invention is that the decoding of bins from two or more partial bitstreams can be performed in parallel (for example, for groups with different probability scales), thereby reducing the processing time for multiple configurations.

[0072] Another advantage of embodiments of the present invention is that the bin decoding performed by the bin decoder 322 can be specifically designed for different sets of parameters 317. In particular, the encoding and decoding of bins can be optimized (with respect to encoding efficiency and / or complexity) for each different group of estimated probabilities. On the one hand, such optimization can reduce the encoding / decoding complexity compared to existing entropy encoding algorithms with similar encoding efficiency. On the other hand, such optimization enables improved encoding efficiency compared to existing entropy encoding algorithms with similar encoding / 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 sequences to codewords) for each different group of probabilistic estimates for one of two possible bin values ​​317 with respect to the current bin request. In a further preferred embodiment of the present invention, the bin decoder 322 performs a different decoding algorithm for each different group of probabilistic estimates for bin values ​​with inferior or superior probabilities with respect to the currently requested bin.

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

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

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

[0076] Accordingly, Figures 7 and 8 illustrate embodiments of an encoder for encoding a sequence of symbols 301 and a decoder for reconstructing it. The encoder includes an assignment unit 304 configured to assign several parameters 305 to each symbol in the sequence of symbols. This assignment is based on information contained in the preceding symbols of the sequence of symbols, such as the category of the syntax element 301, and is an assignment to the representation to which the current symbol belongs—for example, a binaryization—which is expected at the present time according to the syntax structure of the syntax element 301, and is inferred from the history of the preceding syntax element and symbol 301. Furthermore, the encoder includes a plurality of entropy encoders 310, each configured to convert the symbols 301 sent to each entropy encoder into their respective bitstreams 312, and a selection unit 306 configured to send each symbol 301 to one of the plurality of entropy encoders 310, the selection of which is based on the number of parameters 305 assigned to each symbol 301. It can also be thought of that the allocation unit 304 is integrated with the selection unit 306 to obtain each selection unit 502.

[0077] A decoder for reconstructing a symbol sequence includes: a plurality of entropy decoders 322, each configured to convert each bitstream 323 into a symbol 321; an assignment unit 316 configured to assign several 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 Figure 8); and a selection unit 318 configured to retrieve each symbol of the symbol sequence to be reconstructed from one of the plurality of entropy decoders 322, the selection depending on the number of parameters defined for each symbol. The assignment unit 316 may be configured such that the number of parameters assigned to each symbol includes or is the measure for estimating the probability distribution of the possible symbol values ​​that each symbol may have. Alternatively, the assignment unit 316 and the selection unit 318 may be considered to be integrated into a single block, namely a selection unit 402. The symbol sequence to be reconstructed is created from a binary alphabet, and the assignment unit 316 may be configured such that the probability distribution estimation consists of a measure for the probability estimation of a bin value having a lower probability or a higher probability of two possible bin values ​​in the binary alphabet, and an identifier that specifies the estimation of which of the two possible bin values ​​represents the lower probability or the higher probability of the bin value. The assignment unit 316 may further be configured to internally assign a context to each symbol in the symbol sequence 315 to be reconstructed, based on information contained in the previously reconstructed symbols of the symbol sequence to be reconstructed, where each context is associated with its respective probability distribution estimation, and the assignment unit 316 may further be configured to adapt the probability distribution estimation for each context to actual symbol statistics based on the symbol values ​​of the previously reconstructed symbols to which each context was assigned. This context may take into account the spatial relationships or proximity of the locations to which syntax elements belong in video or picture encoding, or in tables in financial applications.Next, a measure for estimating the probability distribution for each symbol may be determined based on the probability distribution estimate associated with the context assigned to each symbol, which may be done, for example, by quantizing the probability distribution estimate associated with the context assigned to each symbol (indicated in the following embodiments by the pipe index and the refined index) to one of a group of representative values ​​for probability distribution estimates (the refined index is decoupled) or by using it as an index to the respective table, thereby obtaining a measure for probability distribution estimates (where the pipe index indicates partial bitstream 312). The selection unit may be configured to define a bijective association between a group of entropy encoders and a group of representative values ​​for probability distribution estimates. The selection unit 318 may be configured to change the quantization mapping over time from a range of probability distribution estimates to representative values ​​for a group of probability distribution estimates in a predetermined deterministic way based on previously reconstructed symbols of the symbol sequence. In other words, the selection unit 318 can change the size of the quantization step, i.e., the interval of the probability distribution mapped to individual probability indices, which may be bijectively associated with individual entropy decoders. The multiple entropy decoders 322 may then be configured to adapt the method of converting symbols to bitstreams in response to changes in the quantization mapping. For example, each entropy decoder 322 may have an optimal compression ratio, i.e., it may be optimized for a given probability distribution estimation within the quantization interval of its respective probability distribution estimation, and as the entropy decoder 322 changes to optimize itself, it may change the mapping of its codeword / symbol sequence to adapt the position of this given probability distribution estimation within the quantization interval of its respective probability distribution estimation. The selection unit may be configured to change the quantization mapping so that the variability in the rate at which symbols are recovered from the multiple entropy decoders is reduced. It should be noted that the binaryizer 314 may be omitted if the syntax elements are already binary.Furthermore, depending on the type of decoder 322, buffer 320 may not be necessary. Alternatively, the buffer may be integrated within the decoder.

[0078] <End of finite sequence of syntax elements> In a preferred embodiment of the present invention, encoding and decoding are performed on a finite set of syntax elements. Often, a predetermined amount of data is encoded, such as a still image, frames or fields of a video sequence, slices of an image, slices of frames or fields of a video sequence, or a set of consecutive audio samples. In the case of a finite set of syntax elements, it is generally necessary to terminate the partial bitstream created on the encoder side. That is, it must be ensured 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 the 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, then the bin sequences stored in the bin buffer after the last bin is written to the bin buffer may not represent the bin sequences associated with the codeword (i.e., they may represent prefixes of two or more bin sequences associated with the codeword). In such cases, any codeword associated with a bin sequence that contains that bin sequence as a prefix in the bin buffer must be written to the partial bitstream (the bin buffer must be flushed). This can be done by inserting bins with specific or arbitrary values ​​into the bin buffer until a codeword is written. In a preferred embodiment of the present invention, the bin encoder selects one of the codewords having the shortest length (in addition to the characteristic that the associated bin sequence must contain that bin sequence as a prefix in the bin buffer). On the decoder side, the bin decoder 322 may decode more bins than requested for the last codeword in the partial bitstream, and these bins are discarded and ignored as they are not requested by the bin buffer selector 318. Decoding of a finite set of symbols is controlled by requests for decoded syntax elements; that is, if no further syntax elements are requested for a certain amount of data, the decoding terminates.

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

[0080] In one embodiment of the present invention, each partial bitstream relating to a certain amount of data is written to a single data packet. This amount of data may be any set of syntax elements, such as a still image, fields or frames of a video sequence, slices of a still image, slices of fields or frames of a video sequence, or frames of an audio sample.

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

[0082] A data packet 400 consists of a header and a partition for each partial bitstream data (related to a certain amount of data under consideration). The header 400 of the data packet contains instructions for dividing the data packet (the rest of it) into segments 402 of bitstream data. In addition to instructions for partitioning, the header may contain further information. In a preferred embodiment of the present invention, the instructions for partitioning the data packet are the starting position of the data segment in units of bits or bytes, or in units of a large number of bits or bytes. In a preferred embodiment of the present invention, the starting position of the data segment is encoded as an absolute value within the header of the data packet and is the position relative to the starting point of the data packet, or the position relative to the ending point of the header, or the position relative to the starting point of a preceding data packet. In a further preferred embodiment of the present invention, the starting position of the data segment is encoded differentially; that is, only the difference between the actual starting point of the data segment and the prediction of the starting point of the data segment is encoded. This prediction can be derived based on already known or transmitted information, such as the overall size of the data packet, the size of the header, the number of data segments within the data packet, and the starting position of preceding data segments. In a preferred embodiment of the present invention, the starting position of the first data packet is not encoded but is inferred based on the size of the data packet header. On the decoder side, the transmitted partition indication is used to derive the starting point of the data segment. The data segment is then used as a partial bitstream, and the data contained in the data segment is sequentially fed to the corresponding bin decoder.

[0083] There are several options for multiplexing a partial bitstream into a data packet. One method, shown in Figure 10, can reduce necessary side information, especially when the sizes of the partial bitstreams are very similar. The data packet payload, i.e., the data packet 410 without its header 411, is divided into segments 412 in a predefined manner. For example, the data packet payload can be divided into segments of the same size. Next, each segment is associated with the first part of a partial bitstream or partial bitstream 413. If the partial bitstream is larger than the associated data segment, the remaining part 414 is placed in unused space at the end of the other data segment. This can be done by inserting the remaining parts of the bitstream in reverse order (starting from the end of the data segment), reducing side information. The association of the remaining parts of a partial bitstream with a data segment, and the starting points for one or more remaining parts when two or more remaining parts are added to a data segment, need to be signaled within the bitstream, for example, in the data packet header.

[0084] <Interleaving of variable-length codewords> In some applications, the aforementioned multiplexing of partial bitstreams (related to a certain amount of syntax elements) within a single data packet can have the following drawbacks: On the one hand, for small data packets, the number of bits required for side information to signal the partition can become significant compared to the actual data within the partial bitstream, ultimately reducing encoding efficiency. On the other hand, multiplexing can be unsuitable for applications requiring low latency (such as video conferencing applications). In the case of the aforementioned multiplexing, it is impossible for the encoder to begin transmitting the data packet before the partial bitstream is fully created, because the starting position of the partition is not known in advance. Furthermore, the decoder generally needs to wait until it receives the starting point of the last data segment before it can begin decoding the data packet. In applications such as video conferencing systems, these delays can add up to an additional overall delay in systems using multiple video pictures (especially with respect to bitrates close to the transmission bitrate, and with respect to encoders / decoders that require close to the time interval between two pictures to encode / decode one picture), which can be fatal for such applications. To overcome these drawbacks for specific applications, an encoder in a preferred embodiment of the present invention may be configured such that 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 (see below if small buffer delays are ignored). On the decoder side, the two or more bin decoders read the codewords directly from the bitstream in the order of decoding. That is, decoding can begin with the first bit received. Furthermore, side information is not required to signal the multiplexing (or interleaving) of partial bitstreams.If the bin decoder 322 does not read variable-length codewords from the global bit buffer, but instead always reads fixed-length bit sequences from the global bit buffer and appends these fixed-length bit sequences to the local bit buffer, a further method for reducing decoder complexity is obtained. Here, each bin decoder 322 is concatenated with a separate local bit buffer. The variable-length codeword is then read from the local bit buffer. This allows the analysis of the variable-length codeword to be performed in parallel, and access to the fixed-length bit sequences only needs to be performed synchronously, however such access to the fixed-length bit sequences is usually very fast, so consequently, the overall decoding complexity can be reduced for some architectures. The fixed number of bins sent to a particular local bit buffer may differ from one local bit buffer to another 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 that particular access. This is a significant difference from reading variable-length codewords. The reading of a fixed-length bit string is triggered by a predetermined event in the bin buffer, bin decoder, or local bit buffer. For example, if the number of bits present in a concatenated bit buffer falls below a predetermined threshold, it is possible to request the reading of a new fixed-length bit string. In this case, different thresholds can be used for different bit buffers. The encoder must ensure that the fixed-length bin string is inserted into the bitstream in the same order as it is read from the bitstream by the decoder. This interleaving of fixed-length strings can also be combined with low-latency control similar to that described above. A preferred embodiment for interleaving fixed-length bit strings is described below. For details on such an interleaving scheme, please refer to Patent Document 1.

[0085] Following a description of embodiments in which the previous encoding is used for video data compression, further embodiments for carrying out embodiments of the present invention will be described, which provide a particularly efficient configuration with respect to a compromise between compression ratio and lookup table and computational overhead. In particular, the following embodiments enable the use of computationally less complex variable-length codes to entropically encode bitstreams individually and efficiently cover the probabilistic estimation portion. In the embodiments described below, the symbols have binary properties, and the VLC codes described below have a range of, for example, [0;0.5]. LPS It efficiently covers probability estimations such as those represented by [this formula].

[0086] In particular, the following embodiments describe possible embodiments of the individual entropy encoder 310 and decoder 322 shown in Figures 7 to 17. These embodiments are suitable for encoding bins, or binary symbols, when they appear in image or video compression applications. Accordingly, these embodiments are also applicable to image or video encoding in which such binary symbols are divided into one or more binstreams 307 to be encoded and one or more bitstreams 324 to be decoded, each of which can be considered an implementation of the Bernoulli process. The embodiments described below encode binstreams using various so-called variable / variable codes (v2v codes) described below. A v2v code may be thought of as two unprefixed codes having the same number of codewords; that is, primary and secondary unprefixed codes. Each codeword of the primary unprefixed code is associated with one codeword of the secondary unprefixed code. According to the embodiments described below, at least some of the encoders 310 and decoders 322 operate as follows: Whenever a primary unprefixed codeword is read from buffer 308 to encode a particular bin sequence 307, the corresponding secondary unprefixed codeword is written to bitstream 312. A similar process is used to decode such bitstream 324, except that the primary and secondary unprefixed codes are swapped. That is, whenever a secondary unprefixed codeword is read from each bitstream 324 to decode bitstream 324, the corresponding primary unprefixed codeword is written to buffer 320.

[0087] Advantageously, the codes described below do not require a lookup table. These codes 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 a large table for codewords. Instead, coding and decoding can be performed using simple algorithms. Three construction rules are described below, two of which are parameterizable. They also cover different or disparate parts of the probability intervals mentioned above, and therefore it is particularly advantageous to use all three codes (each in parallel for each of the different 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 one of the codes works well with respect to excessive code lengths in a Bernoulli process with any probability p.

[0088] As described above, the encoding and decoding of streams 312 and 324 may be performed independently for each stream or in an interleaved manner. However, this is not unique to the category of v2v codes described herein. Therefore, in the following description, only the encoding and decoding of specific codewords are described for each of the three construction rules. However, it should be emphasized here that all of the embodiments described above relating to interleaving solutions can also be combined with the codes, or encoders 310 and decoders 322, described herein, respectively.

[0089] Construction Rule 1: "Unarybin PIPE" code or encoder 310 / decoder 322 Unary bin PIPE coding (PIPE = probability interval partitioning entropy) is a special version of so-called "bin PIPE" coding, i.e., coding suitable for encoding individual bitstreams 312 and 324 that transmit binary symbol statistics data, each belonging to a given probability sub-interval within the aforementioned probability range [0;0.5]. First, we will explain the construction of bin PIPE coding. Bin PIPE coding can be constructed from any unprefixed coding having at least three codewords. To form one v2v coding, bin PIPE coding uses unprefixed coding as the primary and secondary coding, however, the two codewords of the secondary unprefixed coding are swapped. This means that, except for the two codewords, the bins are written to the bitstream unchanged. According to this technique, only one unprefixed coding needs to be stored with the information, and memory consumption is reduced because the two codewords are swapped. Note that there is meaning in swapping codewords of different lengths. Otherwise, the bitstream could end up having the same length as the binstream (without taking into account the effects that occur at the end of the binstream).

[0090] This construction rule gives rise to a notable characteristic of bin PIPE codes: when primary and secondary prefix-less codes are swapped (while the codeword mapping is preserved), the resulting v2v code is identical to the original v2v code. Therefore, the coding and decoding algorithms are identical for bin PIPE codes.

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

[0092] Example for n=4: Number 1st round 2nd round 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" Codes and Unary-to-Rice Encoder 10 / Decoder 22: Unary-to-rice coding uses truncated unary codes as primary codes. That is, unary codewords start from '1', '01', '001', and so on. nCodewords are generated until +1 codewords are produced, and the longest codeword is followed by the removal of the last 1. n is a parameter of the unary-to-rice code. Second-order unprefixed codes are constructed from the codewords of first-order unprefixed codes as follows: For first-order codewords consisting only of 0s, the codeword '1' is assigned. All other codewords consist of a concatenation of codewords '0', each having an n-bit binary representation of the number of 0s in the corresponding first-order unprefixed codeword.

[0094] Example for n=3: Number 1st round 2nd round 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 the Rice parameter 2 n Note that this is equivalent to mapping to a Rice code that has [a specific character].

[0095] Construction Rule 3: "Three Bins" Code The three bin codes are given as follows: Number 1st round 2nd round 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] The first-order code (symbol sequence) has a fixed length (always 3 bins), and the codewords are sorted in ascending order of the number of 1s.

[0097] An efficient example of a three-bin code configuration is described below. The encoder and decoder for this three-bin code can be configured without storing a table, as follows:

[0098] In the encoder (one of the 10), three bins are read from the binstream (i.e., 7). If these three bins contain only one 1, the codeword '1' is written to the bitstream, followed by two bins consisting of the binary representation of position 1 (starting from right-to-left 00). If the three bins contain only one 0, the codeword '111' is written to the bitstream, followed by two bins consisting of the binary representation of position 0 (starting from right-to-left 00). The remaining codewords '000' and '111' are mapped to '0' and '11111' respectively.

[0099] In one of the decoders (22), one bin or bit is read from the respective bitstream 24. If one bin or bit is equal to '0', the codeword '000' is decoded into binstream 21. If it is equal to '1', two more bins are read from bitstream 24. If these two bits are not equal to '11', these bits are interpreted as a binary representation of a number, and two 0s and one 1 are decoded from the bitstream such that the position of this 1 is determined by that number. If two bits are equal to '11', two more bits are interpreted as a binary representation of a number. If this number is less than 3, two 1s and one 0 are decoded, and this number determines the position of the 0. If it is equal to 3, '111' is decoded into the binstream.

[0100] An efficient example of a uni-libin PIPE code configuration is described below. Encoders and decoders for uni-libin PIPE codes can be efficiently implemented using counters. The structure of bin PIPE codes makes encoding and decoding them easy.

[0101] In any of the 10 encoders, if the first bin of a codeword is equal to '0', the bin is processed until a '1' occurs or n zeros (including the first '0' of the codeword) are read. If a '1' occurs, the read bin is written to the bitstream unchanged. Otherwise (i.e., n zeros are read), n-1 ones are written to the bitstream. If the first bin of a codeword is equal to '1', the bin is processed until a '0' occurs or n-1 ones (including the first '1' of the codeword) are read. If a '0' occurs, the read bin is written to the bitstream unchanged. Otherwise (i.e., n-1 ones are read), n zeros are written to the bitstream.

[0102] In the decoder (one of the 322), the same algorithm as the encoder is used. This is because, as mentioned above, it is the same for bin PIPE coding.

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

[0104] In the encoder (any of 310), the bins either produce 1 or 2 n Read from the binstream (i.e., 7) until 0 is read. The number of 0s is counted. n If the number is equal to n, the codeword '1' is written to the bitstream. Otherwise, '0' is written, followed by the n-bit binary representation of the counted number.

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

[0106] In other words, the embodiment described immediately above describes an encoder for encoding a sequence of symbols 303, the encoder comprising an assignment unit 316 configured to assign several parameters 305 to each symbol of the symbol sequence based on information contained within a previous symbol of the symbol sequence, a plurality of entropy encoders 310 configured to convert each symbol 307, respectively transmitted to each of the respective entropy encoders 310, into a respective bit stream 312, and a selection unit 6 configured to transmit each symbol 303 to a selected one of the plurality of entropy encoders 310, the selection depending on the number of parameters 305 assigned to each symbol 303. According to this embodiment, at least a first subset of the entropy encoders may be variable length encoders configured to map a variable length symbol sequence within the stream of symbols 307, respectively, into a variable length code word to be inserted into the bit stream 312, wherein each of the entropy encoders 310 of the first subset uses a bijective mapping rule, based on which a code word of a first prefix-free code having (2n - 1) ≧ 3 code words is mapped into a code word of a second prefix-free code identical to a first prefix code, such that all but two of the code words of the first prefix-free code are mapped into the same code word of the second prefix-free code, while the two code words of the first and second prefix-free codes have different lengths and are mapped in an interchanged state, where different n may be used for different entropy encoders in order to cover different parts of the intervals of the probability intervals described above. The first prefix-free code has code words 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 Two codewords, configured in such a way that they are mutually interchangeable, are mapped to the following states: (a,...,a) n (b,...,b) n-1 And so, where b ≠ a and a, b ∈ {0, 1}. However, an alternative method is also feasible.

[0107] In other words, each of the first subsets of entropy encoders, when converting the symbols transmitted to each entropy encoder into their respective bitstreams, examines the first symbol transmitted to each entropy encoder. (1) Determine if the first symbol is equal to a ∈ {0, 1}, and if so, each entropy encoder examines the subsequent symbols transmitted to each entropy encoder, (1.1) Determine whether b ≠ a and b ∈ {0, 1} occurs in the next n-1 symbols following the first symbol, and if so, each entropy encoder is configured to write a codeword to each bitstream that is equivalent to the state in which subsequent symbols transmitted to each entropy encoder follow the first symbol, up to the 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 is (b,...,b) n-1 Configured to write a codeword to each bitstream equal to, (2) Determine whether the first symbol is equal to b, and if so, each entropy encoder examines the subsequent symbols transmitted to each entropy encoder, (2.1) Determine whether a occurs within the next n-2 symbols following the first symbol, and if so, each entropy encoder is configured to write a codeword to each bitstream that is equivalent to the state in which subsequent symbols transmitted to each entropy encoder after the first symbol are followed by 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 is (a,...,a) n It is configured to write a codeword to each bitstream that is equal to [the specified value].

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

[0109] Here again, from the perspective of the operation modes of each encoder 10, each of the second subsets of the entropy encoders converts the symbols transmitted to each entropy encoder into their respective bitstreams until a occurs, or when the number of symbol sequences transmitted to each entropy encoder is 2 n There are 2 in the column. n 2 such that all symbols are b n It may be configured to count the number of b in the symbol sequence transmitted to each entropy encoder until it reaches a certain number. (1) The number of b is 2 n If equal to the above, write c ∈ {0,1} as the codeword of a second-order prefix-less code to each bitstream. (2) The number of b is 2 n If it is smaller, write a codeword of a second-order unprefixed code to each bitstream, having (d) as a prefix such that c≠d and d∈{0,1}, and an n-bit word determined according to the number of b as a suffix.

[0110] Furthermore, or alternatively, one of the predetermined entropy encoders 10 may be a variable-length encoder configured to map fixed-length symbol sequences to variable-length codewords, the predetermined entropy encoder using a bijective mapping rule, and based on this bijective mapping rule, 2 having a primary code length of 3. 3Each codeword is mapped to a codeword of a secondary code without a prefix. As a result, the primary codeword (aaa)3 with a∈{0,1} is mapped to the codeword (c) with c∈{0,1}, all three primary codewords with only one b where b≠a and b∈{0,1} are mapped to a codeword with a prefix (d) where c≠d and d∈{0,1} and a suffix of each first 2-bit word from a first set of 2-bit words, and all three primary codewords with only one a are mapped to a codeword with a prefix (d) and a suffix of 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 2-bit words. The codeword (bbb)3 is mapped to a codeword having (d) as a prefix and a suffix consisting of 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. The first 2-bit word of a primary code codeword having only one b may be a 2-bit representation of the position of b within each primary codeword, and the second 2-bit word of a primary code codeword having only one a may be a 2-bit representation of the position of a within each primary codeword. However, alternative methods are also feasible.

[0111] Here too, one of the entropy encoders may be configured to check the symbols in a triplet (a set of three elements) to the given entropy encoder in the following respects when converting the symbols transmitted to the given entropy encoder into their respective bitstreams: (1) A triplet is checked to see if it consists of multiple as, and if so, a predetermined entropy encoder is configured to write a codeword (c) to each bitstream. (2) It is checked whether the triplet contains only one b, and if so, a predetermined entropy encoder is configured to write a codeword to each bitstream having (d) as a prefix and a 2-bit representation of the position of b in the triplet as a suffix, (3) It is checked whether the triplet contains only one a, and if so, a predetermined entropy encoder is configured to write to each bitstream a codeword having (d) as a prefix and having as a suffix a 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, and if so, a predetermined entropy encoder may be configured to write to each 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] With respect to the decoding side, the embodiment described above discloses a decoder for reconstructing a sequence of symbols 326, comprising: a plurality of entropy decoders 322, each configured to convert its respective bitstream 324 into a symbol 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 one of the plurality of entropy decoders, the selection depending on the number of parameters defined for each symbol. According to this embodiment, at least a first subset of the entropy decoder 322 is a variable-length decoder configured to map variable-length codewords to variable-length symbol sequences, where each of the entropy decoders 322 in the first subset uses a bijective mapping rule, and based on this bijective mapping rule, a codeword of a first-order unprefixed code having (2n-1) ≥ 3 codewords is mapped to a second-order unprefixed code that is identical to the first-order prefixed code. As a result, all but two of the first-order unprefixed codewords are mapped to the same second-order unprefixed codewords, while the two codewords of the first-order and second-order unprefixed codes have different lengths and are mapped interchangeably, where each entropy decoder uses a different n. The first prefix-less code is one whose codeword is (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 the two codewords mapped in a mutually interchangeable state are (a,...,a) n and (b,...,b) n-1 This can be constructed such that b≠a and a,b∈{0,1}. However, alternative methods are also feasible.

[0113] Each of the first subsets of the entropy decoder may be configured to check the first bit of each bitstream for the following reasons when converting each bitstream to a symbol: namely, (1) Determine if the first bit is equal to a ∈ {0, 1}, and if so, each entropy decoder is configured to examine the subsequent bits of each bitstream. (1.1) Determine whether there is a b such that b≠a and b∈{0,1} in the next n-1 bits following the first bit, and if so, each entropy decoder is configured to reconstruct a symbol sequence equivalent to the state in which the subsequent bits of each bitstream follow the first bit up to bit b, or (1.2) Determine if b does not occur at all in the next n-1 bits following the first bit, and if so, each entropy decoder is (b,...,b) n-1 Configured to reconstruct a sequence of symbols equal to, (2) Determine if the first bit is equal to b, and if so, each entropy decoder is configured to examine the subsequent bits of each bitstream. (2.1) Determine whether a occurs within the next n-2 bits following the first bit, and if so, each entropy decoder is configured to reconstruct a symbol sequence that is equivalent to the state in which the subsequent bits of each bitstream follow the first bit up to symbol a, or (2.2) Determine whether a does not occur at all in the next n-2 bits following the first bit, and if so, each entropy decoder is (a,...,a) n It may be configured to reconstruct a sequence of symbols equal to .

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

[0115] Each of the second subset of entropy decoders may be a variable-length decoder configured to map fixed-length codewords to variable-length symbol sequences, and each entropy decoder may be configured to check the first bit of each bitstream for the following reasons when converting the bitstream to symbols: namely, (1) Determine if the first bit is equal to c such that c ∈ {0, 1}, and if so, each entropy decoder is such that b ∈ {0, 1} (bb...b)² n Configured to reconstruct a sequence of symbols equal to, (2) Each entropy decoder may determine whether the first bit is equal to d such that c≠d and c,d∈{0,1}, and if so, determine an n-bit word from the n further bits of the respective bitstream following the first bit, and from that n-bit word, reconstruct a symbol sequence of type {(a),(ba),(bba),...,(b...ba),(bb...b)} such that b≠a and b∈{0,1}, where the number of b depends on the n-bit word.

[0116] Additionally or alternatively, one of the entropy decoders 22 may be a variable-length decoder configured to map variable-length codewords to fixed-length symbol sequences, the specified entropy decoder using a bijective mapping rule, based on this bijective mapping rule, the codeword of a secondary unprefixed code is 2 times the length 3 of the primary code. 3They are mapped to individual codewords, and as a result, a codeword (c) where c∈{0,1} is mapped to a primary code codeword (aaa)3 where a∈{0,1}, and a codeword having (d) as a prefix where c≠d and d∈{0,1} and having each of the first two-bit words from the first set of three two-bit words as a suffix is ​​mapped to all three primary code codewords having only one b where b≠a and b∈{0,1}, with (d) as a prefix and A codeword having a suffix that is a concatenation of a first 2-bit word that has and is not an element of the first set and a second 2-bit word from a second set consisting of three 2-bit words is mapped to all three codewords of a primary code having only one a, and a codeword having a suffix that is a concatenation of a first 2-bit word that has (d) as a prefix and 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 codeword (bbb)3. The first 2-bit word of a primary code codeword having 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 a primary code codeword having 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.

[0117] One of the entropy decoders may be a variable-length decoder configured to map a variable-length codeword to a symbol sequence consisting of three symbols each, and each entropy decoder may be configured to check the first bit of each bitstream when converting the bitstream to symbols, namely, (1) Determine whether the first bit of each bitstream is equal to c such that c ∈ {0, 1}, and if so, the given entropy decoder is configured to reconstruct a symbol sequence equal to (aaa)3 such that a ∈ {0, 1}, or (2) Determine whether the first bit of each bitstream is equal to d such that c≠d and d∈{0,1}, and if so, a given entropy decoder is configured to determine a first two-bit word from two further bits following the first bit of each bitstream, and further examine that first two-bit word, (2.1) Determine whether the first 2-bit word is an element of a first set consisting of three 2-bit words. If so, the given entropy decoder is configured to reconstruct a symbol sequence having only one b such that b≠a and b∈{0,1}, where the position of b in each symbol sequence depends on the first 2-bit word, or (2.2) Determine whether the first two-bit word is an element of the first set, and if so, the given entropy decoder is configured to determine a second two-bit word from two additional bits of each bitstream that follow the two bits from which the first two-bit word was determined, and is further configured to examine the second two-bit word. (3.1) Determine whether the second 2-bit word is an element of a second set consisting of three 2-bit words, and if so, the given entropy decoder is configured to reconstruct a symbol sequence having only one a, where the position of a in each symbol sequence depends on the second 2-bit word, or (3.2) Determine whether the second 2-bit word is an element of a second set consisting of three 2-bit words, and if so, a given entropy decoder may be configured to reconstruct a symbol sequence equal to (bbb)3.

[0118] After explaining the overall concept of the video encoding scheme, embodiments of the present invention will be described in relation to the embodiments described above. In other words, the embodiments described below may be implemented using the scheme described above, and conversely, the encoding scheme described above may be implemented using and developed using the embodiments described below.

[0119] In the embodiments described above in relation to Figures 7-9, the entropy encoders and decoders in Figures 1-6 were configured according to the concept of PIPE. In one particular embodiment, an arithmetic single-stochastic-state encoder 310 / decoder 322 was used. As described below, according to other embodiments, entities 306-310 and their 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 encode all symbols into a single common bitstream, thereby eliminating the need to interleave partial bitstreams, as described below, while giving up the favorable aspects of the current PIPE concept regarding parallel processing. In this way, the number of underlying stochastic states from which the probability of the context is estimated by updates (table lookups) may be greater than the number of underlying stochastic states from which the subdivision of the probability interval is performed. That is, the stochastic state index may also be quantized, just as the value of the probability interval width is quantized before indexing into the table Rtab. Therefore, the possible configurations for the single encoder 310 and decoder 322 described above can be broadly interpreted as examples of configurations for entropy encoders / decoders 318-322 / 306-310 as engines for context-adaptive binary arithmetic coding / decoding.

[0120] More specifically, according to one embodiment, the output of the parameter assignment unit (which acts as the context assignment unit) may behave as follows: 0. The allocation unit 304 transmits the bin value along with the probability parameter. The probability is pState_current[bin]. 1. Therefore, the entropy coding engine receives 1) valLPS, 2) bins, and 3) a probability distribution estimate pState_current[bin]. pState_current[bin] may have more states than the number of identifiable probability state indices in Rtab. In that case, pState_current[bin] may be quantized, for example by ignoring m LSBs, where m is greater than or equal to 1, perhaps 2 or 3, in order to obtain one p_state, i.e., the index to be used to access the table Rtab next. However, this quantization is not required; that is, p_state may be pState_current[bin]. 2. Next, quantization of R is performed (either, as described above, one R (and corresponding L with one common bitstream) is used / processed for all identifiable values ​​of p_state, or one R (and corresponding L with an associated partial bitstream for each R / L pair) is used / processed for each identifiable value of p_state, in the latter case which would be equivalent to having one bin encoder 310 for each such value). q_index = Qtab[R>>q] (or other forms of quantization) 3. Next, R LPS The decision of R is then executed. R LPS =Rtab[p_state][q_index]; Rtab already stores pre-calculated values ​​for p[p_state]·Q[q_index]. R=RR LPS (In other words, R is pre-updated as if "bin" were MPS.) 4. Calculation of new subintervals: If (bin = 1 - valMPS), L￢L+R R￢R LPS 5. Renormalize L and R, and write the bits.

[0121] Similarly, an entropy decoder connected to the output of a parameter assignment unit (which acts here as a context assignment unit) may operate as follows: 0. The allocation unit 304 transmits the bin value along with the probability parameter. The probability is pState_current[bin]. 1. Accordingly, the entropy decoding engine receives a request for a bin along with 1) valLPS and 2) a probability distribution estimate pState_current[bin]. pState_current[bin] may have more states than the number of identifiable probability state indices in Rtab. In that case, pState_current[bin] may be quantized, for example, by ignoring m LSBs. Here, m is greater than or equal to 1, perhaps 2 or 3, in order to obtain one p_state, i.e., the index that will then be used to access the table Rtab. However, this quantization is not required; that is, p_state may be pState_current[bin]. 2. Next, quantization of R is performed (as described above, either one R (and corresponding V with one common bitstream) is used / processed for all identifiable values ​​of p_state, or one R (and corresponding V with associated partial bitstreams for each R / L pair) is used / processed for each identifiable value of p_state, in the latter case which would be equivalent to having one bin encoder 310 for each such value). q_index = Qtab[R>>q] (or other forms of quantization) 3. Next, R LPS The decision of R is then executed. R LPS =Rtab[p_state][q_index]; Rtab already stores pre-calculated values ​​for p[p_state]·Q[q_index]. R=RR LPS (In other words, R is pre-updated as if "bin" were MPS.) 4. Determining bins based on the location of sub-intervals: (V 3 In the case of R), bin ¬ 1-valMPS (The bin is decoded as LPS. The bin buffer selection unit 18 uses this bin information and valMPS to obtain the actual bin value.) V￢VR R￢R LPS At other times, bin ￢ valMPS (The bin is decoded as MPS. The actual bin value is obtained using this bin information and valMPS.) 5. Renormalize R, read out one bit, and update V.

[0122] As described above, the allocation unit 4 assigns pState_current[bin] to each bin. This association may be performed based on the selection of a context. That is, the allocation unit 4 may select a context using a context index ctxIdx, to which each pState_current is associated. Probability updates 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 encoded bits. If (bit = 1 - valMPS), pState_current ← Next_State_LPS [pState_current] (If pState_current = 0) then valMPS ← 1-valMPS Other cases pState_current ← Next_State_MPS [pState_current]

[0123] If two or more contexts are given, the adaptation is performed for each context. That is, pState_current[ctxIdx] is used for encoding and then updated using 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 configured to operate in different modes, namely low complexity (LC) and high efficiency (HE) modes, although this will be discussed primarily in relation to PIPE coding (and the LC and HE-PIPE modes). However, the details of complexity scalability can be readily applied to other configurations of the entropy coding / decoding engine, such as embodiments using a single common context-adaptive arithmetic encoder / decoder.

[0125] According to the embodiments described below, both modes of entropy coding are shareable in the following respect: • (For syntax elements 301 and 327, respectively) the same syntax and semantics • The same binaryization scheme applies to all syntax elements (as currently specified for CABAC) (i.e., the binaryizer may operate regardless of the activated mode). • Use of the same PIPE code (i.e., the bin encoder / decoder may operate regardless of the activated mode) • Use of 8-bit probabilistic model initialization values ​​(instead of the 16-bit initialization values ​​currently specified for CABAC).

[0126] Generally speaking, LC-PIPE and 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 constraints: namely, there may be only one probabilistic model, i.e., one ctxIdx, for each bin (binIdx). In other words, context selection / adaptation may not be provided within LCPIPE. However, certain syntax elements, such as the syntax elements used for residual coding, may be coded using context, as will be further explained below. Furthermore, all probabilistic 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 also 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, namely significance_coeff_flag and coeff_abs_level_greaterX (where X=1,2), whose semantics will be explained in more detail below, may be assigned to a probabilistic model such that (at least) groups of four syntax elements are coded / decoded using the same model probabilities. Compared to CABAC, the LC-PIPE mode can achieve approximately the same RD performance and processing power.

[0128] HE-PIPE may be conceptually similar to H.264's CABAC, but the following differences exist: namely, binary arithmetic coding (BAC) is replaced by PIPE coding (as in LC-PIPE). Each probabilistic model, i.e., each ctxIdx, may be represented by pipeIdx and refineIdx, where pipeIdx, having a value in the range of 0...7, represents the model probability of eight different PIPE codes. This change only affects the internal representation of the state and does not affect the behavior of the state machine (i.e., the probability estimation) itself. As will be explained in more detail below, the initialization of the probabilistic model may use the 8-bit initialization value described above. Backscanning of the syntax elements coeff_abs_level_greaterX (where X=1,2), coeff_abs_level_minus3 and coeff_sign_flag (their semantics will become clear from the explanation below) may be performed using the same scanning path as the forward scan (used, for example, in coding significance maps). The derivation of the context for encoding coeff_abs_level_greaterX (where X=1,2) may also be simplified. Compared with CABAC, the proposed HE-PIPE can achieve roughly the same RD performance with better processing load.

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

[0130] Accordingly, according to an embodiment of the first aspect of the present invention, a decoder for decoding a data stream may be constructed as shown in Figure 11. The decoder is for decoding a data stream 401, such as an interleaved bitstream 340, in which media data such as video data is encoded. The decoder includes a mode switch 400 configured to activate either a low-complexity mode or a high-efficiency mode depending on the data stream 401. For this purpose, the data stream 401 may include syntax elements, such as binary syntax elements, in which case it may have a binary value 1 which is the mode in which the low-complexity mode should be activated, and a binary value 0 which is the mode in which the high-efficiency mode should be activated. It is obvious that the relationship between the binary value and the encoding mode is switchable, and non-binary syntax elements having three or more possible values ​​are also available. Since the actual choice between the two modes is still unknown before the reception of each syntax element, this syntax element may be contained within a leading header of the data stream 401, which is encoded using, for example, a fixed probability estimate or a probability model, or it may be written directly into the data stream 401, i.e., using bypass mode.

[0131] Furthermore, the decoder in Figure 11 may include multiple entropy decoders 322, each configured to convert codewords in the data stream 401 into partial sequences 321 consisting of symbols. As described above, a de-interleaver 404 may be connected between the entropy decoders 322, with one input to the decoder in Figure 11 to which the data stream 401 is applied, and the other to the input to the decoder. Furthermore, as already described above, each entropy decoder 322 may be associated with its own probability interval, in which case the probability intervals of the different entropy decoders may together cover an overall probability interval from 0 to 1 (or from 0 to 0.5 if the entropy decoders 322 are dealing with MPS and LPS rather than absolute symbol values). Details on this point are as described above. Later, we assume that there are eight decoders, each assigned one PIPE index, but any other number is also possible. Furthermore, one of these coders, exemplified below, having pipe_id 0, is optimized for bins with equi-probable statistics, i.e., bins whose bin values ​​are assumed to be equally likely to be 1 and 0. This decoder may simply pass the bins forward. Each encoder 310 operates similarly. It is also possible that no bin operations are performed by the selectors 402 and 502, respectively, depending on the value of the bin with the highest probability, i.e., valMps. In other words, the entropy of each partial stream is already optimal.

[0132] Furthermore, the decoder in Figure 11 includes a selection unit 402, which is configured to retrieve each symbol of the symbol sequence 326 from one of a selection of entropy decoders 322. As described 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 unit 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 which of the low complexity mode and high efficiency mode is activated, as indicated by the arrow 406.

[0133] As already mentioned above, the reconstruction unit 404 may be part of a predictive block-based video decoder that acts on the fixed syntax and semantics of the syntax elements, i.e., those fixed with respect to mode selection by the mode switch 400. In other words, the construction of the reconstruction unit 404 is not affected by the switchability of the mode. More precisely, the reconstruction unit 404 does not increase implementation overhead due to the switchability of the mode introduced by the mode switch 400, and furthermore, its functionality, at least with respect to residual data and predictive data, is the same regardless of the mode selected by the switch 400. The same applies to the entropy decoder 322. All of these entropy decoders 322 are reused in both modes. Thus, the decoder in Figure 11 is compatible with both modes, namely the low-complexity mode and the high-efficiency mode, without additional implementation overhead.

[0134] A key feature to note is that the decoder in Figure 11 is not limited to operating only on self-sufficient data streams in one mode or the other. Rather, the data stream 401 and decoder in Figure 11 may even be configured to switch between both modes during a single piece of media data, such as in the middle of a video or some audio piece, thereby allowing control of the decoding complexity using a feedback channel from the decoder to the encoder, depending, for example, on battery status or other external or environmental conditions, thereby allowing for situation-dependent lock-loop control of mode selection.

[0135] Therefore, the decoder in Figure 11 operates similarly in both cases, i.e., when LC mode is selected and when HE mode is selected. The reconstruction unit 404 performs reconstruction using the syntax elements and requests the current syntax elements of a given syntax element type by processing or following a certain syntax structure prescription. The de-symbolizer 314 requests several bins to produce a valid binarization for the syntax elements requested by the reconstruction unit 404. As is obvious, in the case of a binary alphabet, the binarization performed by the de-symbolizer 314 simply sends each bin / symbol 326 to the reconstruction unit 404 as the currently requested binary syntax.

[0136] However, the selection unit 402 operates independently of the mode selected by the mode switch 400. The operating mode of the selection unit 402 tends to be more complex in the high-efficiency mode and less complex in the low-complexity mode. Furthermore, as can be seen from the following explanation, the operating mode of the selection unit 402 in the low-complexity mode also tends to reduce the rate at which the selection unit 402 changes the selection between entropy decoders 322 when retrieving consecutive symbols from the entropy decoders 322. In other words, in the low-complexity mode, the probability that directly consecutive symbols will be retrieved from the same entropy decoder among the multiple entropy decoders 322 increases. This allows for faster retrieval of symbols from the entropy decoders 322. On the other hand, in the high-efficiency mode, the operating mode of the selection unit 402 tends to lead to the selection between the entropy decoders 322 as follows. In other words, the selection is such that the probability interval associated with each selected entropy decoder 322 matches in a manner that is closer to the actual symbol statistics of the symbols currently being recovered by the selection unit 402, and as a result, the selection brings about a better compression ratio on the encoding side when generating each data stream according to the high-efficiency mode.

[0137] For example, the different behavior of the selection unit 402 in both modes may be implemented as follows. For example, when the high-efficiency mode is activated, the selection unit 402 may perform the selection among multiple entropy decoders 322 for a given symbol depending on the previously recovered symbols in the symbol sequence 326, and when the low-complexity mode is activated, it may perform the selection independently of the previously recovered symbols in the symbol sequence. The dependence of the symbol sequence 326 on the previously recovered symbols may be based on context adaptability and / or probabilistic adaptability. Both of these adaptability features may be switched off during the period of the low-complexity mode in the selection unit 402.

[0138] In a further embodiment, the data stream 401 may have a structure having continuous parts such as slices, frames, groups of pictures, sequences of frames, or other, and each symbol in a sequence of symbols may be associated with one of a plurality of symbol types. In this case, the selection unit 402 may be configured to change its selection for symbols of a given symbol type in the current part depending on previously recovered symbols of the sequence of symbols of that given symbol type in the current part when the high-efficiency mode is activated, and to keep its selection constant in the current part when the low-complexity mode is activated. In other words, the selection unit 402 may be able to change the selection between the entropy decoders 322 for a given symbol type, but these changes are limited to occurring during transitions between continuous parts. With such a method, the evaluation of actual symbol statistics is limited to the rarity of the time events that occur, while the complexity of the encoding is reduced for the majority of the time.

[0139] Furthermore, each symbol in the symbol sequence 326 may be associated with one of several symbol types, and the selection unit 402 may be configured to select one of several contexts for a predetermined symbol of a predetermined symbol type, depending on previously recovered symbols in the symbol sequence 326, and to perform the selection between the entropy decoders 322 depending on a probabilistic model associated with the selected context, and to update the probabilistic model associated with the selected context depending on a predetermined symbol, while the selection unit 402 is configured to select one of several contexts depending on previously recovered symbols in the symbol sequence 326, and to perform the selection between the entropy decoders 322 depending on a probabilistic model associated with the selected context, and to maintain the probabilistic model associated with the selected context, while the selection unit 402 is configured to maintain the probabilistic model associated with the selected context, while the selection unit 402 can use context adaptability for certain syntax element types in both modes, but suppresses probabilistic adaptability in the case of LC mode.

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

[0141] Furthermore, possible LC-PIPE-specific aspects, namely the LC mode aspects, can also be rephrased as follows: In particular, it is possible to use a non-adaptive probabilistic model in LC mode. The non-adaptive probabilistic model may be hardcoded, i.e., have a constant probability overall, or its probability may be kept constant only while processing one slice, and thus depend on the slice type and QP, i.e., the quantization parameter signaled in the data stream 401 for each slice. By assuming that consecutive bins assigned to the same context follow a fixed probabilistic model, it is possible to decode multiple of those bins in one step, i.e., using the same entropy decoder, assuming they are encoded using the same PIPE code, and to omit probabilistic updates after each decoded bin. Omitting probabilistic updates saves operation between the encoding and decoding processes, thus reducing complexity and resulting in significant simplification in hardware design.

[0142] The constraints of non-adaptive models may be mitigated in such a way that, for all or some selected probabilistic models, probabilistic updates are permitted after the encoding / decoding of a predetermined number of bins using the model is complete. A suitable update interval allows for probabilistic adaptation while also having the ability to decode multiple bins at once.

[0143] The following describes in more detail embodiments common to both LC-PIPE and HE-PIPE that may be scalable in complexity. In particular, the following describes embodiments that can be used in the same way or in a way that is scalable in complexity for both LC-PIPE and HE-PIPE modes. Scalable in complexity means that the LC case can be derived from the HE case by removing special parts or replacing them with something less complex. However, there is a point to note before this description. That is, the embodiment in Figure 11 can be easily converted to the context-adaptive binary arithmetic coding / decoding embodiment described above, in which case the selection unit 402 and the entropy decoder 322 would be condensed into a single context-adaptive binary arithmetic decoder that directly receives the data stream 401 and selects the context for the bins to be derived from the data stream at this point. This is true in particular with respect to context adaptability and / or probabilistic adaptability. In the low-complexity mode, both functionality / adaptability may be switched off or designed to be more relaxed.

[0144] For example, when configuring the embodiment shown in Figure 11, the PIPE entropy coding stage, including the entropy decoder 322, can 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 the case of a context-adaptive binary arithmetic decoder, the decoder can also handle the same stochastic state for different contexts and can use it—or its quantized version—for stochastic subpartitioning. The mapping from the CABAC or stochastic model state, i.e., the state used for stochastic updating, to a stochastic index for referencing within PIPEids or Rtab may be as shown in Table A.

[0145] [Table A]

[0146] This modified encoding scheme may be used as a basis for video encoding techniques that are scalable in complexity. When performing stochastic mode adaptation, the selector 402 or the context-adaptive binary arithmetic decoder may select the PIPE decoder 322, that is, the PIPE index to be used and the stochastic index into Rtab may be derived using the mapping shown in Table A, based on a stochastic state index (exemplarily in the range of 0 to 62) that is related to the symbol to be decoded at the present time (e.g., via context), and the stochastic state index may be updated using specific table walk transition values ​​that point to the next stochastic state index to be referenced, for example, in the case of MPS and LPS, depending on the symbol that has been decoded at the present time. In the case of LC mode, the latter update may not be performed. In the case of a globally fixed stochastic model, even mapping may not be performed.

[0147] However, any setting of entropy coding is available, and the techniques described herein can also be used with minor adaptations.

[0148] The explanation of Figure 11 above provided a somewhat general overview of syntax elements and syntax element types. Below, we will discuss encodings that can construct complexity at the conversion coefficient level.

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

[0150] The order between the end-position syntax element and the first syntax element, the second syntax element and the third syntax element may be the same with respect to the high-efficiency mode and the low-complexity mode. Furthermore, the selection unit 402 is a selection among the entropy decoders 322 for a symbol, and the selection of a symbol from which the de-symbolizer 314 obtains the end-position syntax element, the first syntax element, the second syntax element and / or the third syntax element may be performed differently depending on the activated low-complexity mode or high-efficiency mode.

[0151] In particular, the selection unit 402 may be configured to select one of a plurality of contexts for each symbol of a given symbol type in the symbol subsequence from which the desymbolizer 314 acquires a first syntax element and a second syntax element, depending on previously recovered symbols of the given symbol type in the symbol subsequence, and when the high-efficiency mode is activated, the selection may be performed depending on a probabilistic model associated with the selected context, and when the low-complexity mode is activated, the selection may be performed in a consistent manner piece by piece so that the selection is constant across a series of consecutive subsequences of the subsequence. As described above, the subsequences may be measured as the number of positions to which each subsequence extends when measured along a one-dimensional path 274, or as the number of syntax elements of each type already encoded using the current context. In other words, the binary syntax elements coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 are encoded in a context-adaptive manner by selecting decoder 322 based on, for example, the probabilistic model of the selected context in HE mode. Probabilistic 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 statically maintained for the first part along path 274, and the context can only change in the transition to the next immediately following part along path 274. For example, each part may be defined as having a length of 4, 8, or 16 positions of block 200, regardless of whether a syntax element exists at each position. For example, coeff_abs_greater1 and coeff_abs_greater2 exist only at significant locations, i.e., locations where coeff_significant_flag is 1.Alternatively, each part may be defined as having a length of 4, 8, or 16 syntax elements, regardless of whether the resulting part extends over more block positions. For example, coeff_abs_greater1 and coeff_abs_greater2 exist only at significant positions. Thus, each part of the 4 syntax elements may extend beyond 4 block positions, where no syntax elements such as coeff_abs_greater1 and coeff_abs_greater2 are transmitted at all, because the respective levels at these positions are zero along path 274.

[0152] With respect to symbols of a predetermined symbol type in a symbol sub-sequence from which the de-symbolizer acquires a first syntax element and a second syntax element, the selection unit 402 may be configured to select one of a plurality of contexts for each symbol of that predetermined symbol type, and the selection may depend on the number of previously recovered symbols of the predetermined symbol type in a symbol sub-sequence that have a predetermined symbol value and belong to the same sub-part, or on the number of previously recovered symbols of the predetermined symbol type in a sequence of symbols belonging to the same sub-part. According to the embodiment described above, coeff_abs_greater1 is correct in the first choice, and coeff_abs_greater2 is correct in the second choice.

[0153] Furthermore, for each position in a one-dimensional path where a transformation coefficient level greater than 1 is located according to the first binary syntax element, the third syntax element indicating the amount greater than 1 for each transformation coefficient level at each position may include an integer syntax element, i.e., coeff_abs_minus3. The desymbolizer 314 may be configured to map the domain of a symbol sequence word to the co-domain of an integer syntax element using a mapping function controllable by a control parameter, and further, the control parameter for each integer syntax element may be set depending on the integer syntax element of the preceding third syntax element when the high-efficiency mode is activated, and may be configured to perform the setting in a consistent manner piece by piece so that the setting remains constant across a series of consecutive sub-parts of the subsequence when the low-complexity mode is activated. However, the selection unit 402 is configured to select one of a plurality of entropy decoders (322) for the symbols of a symbol sequence word mapped to integer syntax elements, one of which may be associated with a certain uniform probability distribution in both the high-efficiency mode and the low-complexity mode. That is, the dotted line 407 shows that even the desymbolizer can operate depending on the mode selected by switch 400. Instead of setting the control parameters constant for each piece, the desymbolizer 314 may keep the control parameters constant, for example, for the duration of the current slice, or keep them constant overall over time.

[0154] Next, we will discuss scalable context modeling of complexity.

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

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

[0157] In one preferred embodiment, only the evaluation of the left neighbor is permitted. This results in a reduction of buffers in the processing chain, as it is no longer necessary to store the final block or coded unit line. In another preferred embodiment, only neighbors within the same coded unit are evaluated.

[0158] In one preferred embodiment, all effective neighbors are evaluated. For example, in addition to the upper and left neighbors, the upper left, upper right, and lower left neighbors are evaluated if they are effective.

[0159] In other words, the selection unit 402 in Figure 11 may be configured, when the high-efficiency mode is activated, to select one of several contexts for a given symbol associated with a given block of media data, using previously recovered symbols from a sequence of symbols associated with a larger number of different neighboring blocks of media data, and to perform a selection among the entropy decoders 322 depending on a probabilistic model associated with the selected context. That is, neighboring blocks may be neighbors in the domain of time and / or space. Spatially neighboring blocks are shown, for example, in Figures 1 to 3. In this case, the selection unit 402 may perform contact adaptation in response to the mode selection by the mode switch 400, and since the adaptation is performed based on previously recovered symbols or syntax elements associated with a larger number of neighboring blocks in the case of HE mode compared to the case of LC mode, the storage overhead can be reduced as described above.

[0160] Next, we will describe the coding of motion vector differences with reduced complexity according to one embodiment.

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

[0162] The latest coding techniques for MVD when using CABAC as the 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 the predictive unit (PU). The PU sizes of the upper and left neighbors may have different shapes and sizes than the current PU. Therefore, whenever relevant, the definitions of the upper and left neighbors refer here to the upper and left neighbors of the upper-left corner of the current PU. With respect to the coding itself, only the derivation process for the first bin may vary depending on the embodiment. Instead of evaluating the sum of the absolute values ​​of MV from the neighbors, each neighbor may be evaluated separately. If the absolute value MV of a certain neighbor is valid and exceeds 16, the context model index may be increased to the same number as the context model for the first bin, while the coding of the remaining absolute value MVD levels and positive / negative signs may be positively identical to H.264 / AVC.

[0163] In the MVD encoding technique described above, up to nine bins are encoded using a context model, while the remaining values ​​of the MVD may be encoded in a low-complexity bypass mode along with the sign information. The technique described in this embodiment reduces the number of bins encoded with the context model, consequently increasing the number of bypasses, and further reducing the number of context models required for MVD encoding. Therefore, the cutoff value decreases from nine to one or two. That is, only the first bin, which determines whether the absolute value of MVD is greater than zero, is encoded using the context model, or only the first and second bins, which determine whether the absolute value of MVD is greater than zero and one, are encoded using the context model, while the remaining values ​​are encoded in bypass mode and / or using VLC coding. All bins resulting from binarization using VLC coding without using unary coding or truncated unary coding are encoded using a low-complexity bypass mode. In the case of PIPE, direct insertion into and from the bitstream is possible. Furthermore, if there are different definitions of the upper and left neighborhoods that lead to a better context model selection for the first bin, those may be used.

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

[0165] As an alternative to the technique of using the 2x5 context described above in absolute value MVD coding, 14 context models (7 for each component) may be used to code 9 unary code binaryization binaries. For example, while the first and second binaries of the unary portion may be coded using 4 different contexts as described above, the fifth context may be used for the third binary, the sixth context for the fourth binary, and the fifth through ninth binaries may be coded using the seventh context. Thus, in this case, 14 contexts are required, and it may even be possible 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 consequently increase the number of bypasses, and to reduce the number of context models required for MVD coding, is to reduce the cutoff value from, for example, 9 to 1 or 2. In other words, either only the first bin, which determines whether the absolute value MVD is greater than zero, is encoded using the context model, or only the first and second bins, which determine whether the absolute value MVD is greater than zero and 1, are encoded using their respective context models, while the remaining values ​​are encoded using VLC coding. All bins resulting from the binarization using VLC coding are encoded using a low-complexity bypass mode. In the case of PIPE, direct insertion into and from the bitstream is possible. Furthermore, the embodiments proposed herein use different definitions of the upper and left neighbors to derive a better context model selection for the first bin. In addition, the context modeling may be modified in a way that reduces the number of context models required for the first bin or the first and second bins, thereby achieving further memory reduction. It is also possible to disable the evaluation of neighbors, such as the upper neighbor, thereby achieving line buffer / memory savings required for storing the neighbor mvd values.Finally, the coding order of the above components may be split in a way that allows for the coding of bypass bins after the coding of the prefix bins (i.e., bins coded using the context model) for both components.

[0166] In one preferred embodiment, an exponential Golomb code is used to binarize the remaining portion of the absolute mvd component. Therefore, the degree of the exponential Golomb code is variable. The degree of the exponential Golomb code may be derived as follows: After a context model for a first bin and an index of that context model are derived, the index is used as the degree of exponential Golomb binarization. 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 is used as the degree of the exponential Golomb code. This preferred embodiment is applicable to the HE case, where the number of context models is reduced to 6. To further 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 3 context models are required. Furthermore, in a further preferred embodiment of the present invention, only the left neighborhood may be considered for evaluation. In this preferred embodiment, the thresholds may be unmodified (for example, a single threshold 16 with an exponential Golomb parameter of 0 or 1, or a single threshold 32 with an exponential Golomb parameter of 0 or 2). In this preferred embodiment, the line buffer required for storing the mvd value can be saved. In another preferred embodiment, the thresholds are modified to be equal to 2 and 16. For that preferred embodiment, a total of three context models are required for encoding the mvd, and the possible exponential Golomb parameters are in the range of 0 to 2. In a further preferred embodiment, the thresholds are equal to 16 and 32. This embodiment is also suitable for the case of HE.

[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 encoded using context models. The selection of the context model for the first bin may be performed in accordance with the present art or modified in accordance with the preferred embodiments described above. For the second bin, a different context model is selected, as in the present art. In a further preferred embodiment, the context model for the second bin is selected by evaluating the mvd of the left neighbor. In this 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. A total of six context models are required (note that the components share context models). Here 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 is also applicable to 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 the left or upper neighbor. In this preferred embodiment, the total number of context models is equal to 2. In a further preferred embodiment of the present invention, the first and second bins share the same context model. Consequently, only one context model is required 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 degree of the exponential Golomb portion is derived independently of the context model index of the first bin. In this case, the sum of the absolute values ​​of the usual context model selections in H.264 / AV is used to derive the degree of the exponential Golomb portion. This preferred embodiment is suitable for the configuration of HE.

[0170] In another preferred embodiment, the degree of the exponential Golomb code is fixed and set to 0. In yet 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 are applicable to LC. Note that the fixed degree of the exponential Golomb portion is considered using a small number of bins encoded using a 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 value MV is used. This method also applies to the left neighborhood: all PUs covering the current PU are evaluated, and the PU with the maximum value MV is used. In another preferred embodiment, the mean absolute movement vector values ​​from all PUs covering the upper and left boundaries of the current PU are used to derive the first bin.

[0172] In the preferred embodiment proposed above, the encoding order can also be changed as follows: that is, the mvd must be identified sequentially (or vice versa) with respect to the horizontal and vertical directions. Thus, two binstrings need to be encoded. To minimize the number of mode switches (i.e., switches between bypass and normal modes) with respect to the entropy encoding engine, it is possible to encode the bins encoded using the context model for both components in the first step, and then encode the bins encoded in bypass mode in the second step. Note that this only describes the order.

[0173] It should be noted that bins obtained from unary or truncated unary binaryization can also be represented by an equivalent fixed-length binaryization with one flag per bin index that indicates whether the value is greater than the current bin index. For example, if the cutoff value for the truncated unary binaryization of mvd is set to 2, the codewords for values ​​0, 1, and 2 are 0, 10, and 11. In the corresponding equivalent fixed-length binaryization with one flag per bin index, one flag for bin index 0 (i.e., the first bin) indicates whether the absolute value of mvd is greater than 0, and one flag for the second bin with bin index 1 indicates whether the absolute value of mvd is greater than 1. If the second flag is encoded only when the first flag is equal to 1, the result will be the same codewords 0, 10, and 11.

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

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

[0176] The following embodiment illustrates how the internal states of a probabilistic model can be represented in order to avoid the use of lookup tables for converting internal states to PIPE indices. Extracting PIPE indices from the internal state variables of a probabilistic model requires only a simple bit masking operation. This novel representation of the internal states of a probabilistic model, whose complexity is scalable, is designed in a two-level manner. For applications where low-complexity operations are essential, only the first level is used. This level describes only the pipe index and flag valMps used to encode or decode the associated bins. 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 an additional 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 the representation of the probabilities with a higher resolution. Such a more detailed representation allows for more precise manipulation of probability estimators. Generally, this is suitable for coding applications aiming for high RD performance. As an example, this complexity of the internal state of a probabilistic model using PIPE can be represented scalably as follows:

[0177] TIFF2026083042000006.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 MPS value 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, Table B shows the number of CABAC states per PIPE index for the mappings in Table A.

[0179] TIFF2026083042000007.tif26150

[0180] During the bin encoding or decoding process, the PIPE index and valMps can be accessed directly using simple bitmasks or bit shift operations. Low-complexity encoding requires only the first level of 4 bits, while high-efficiency encoding utilizes an additional second level of 4 bits to perform probabilistic model updates of the CABAC probability estimates. To perform these updates, the 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 components. 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 will not exceed 2 × 128 components, which is an acceptable increase in table size. This increase depends on how many bits are used to represent the refined index, and 4 bits are required to accurately mimic the behavior of the CABAC probability estimates. However, different probability estimates may be used that can operate on a reduced set of CABAC states that allow no more than 8 states for each pipe index. Therefore, by adapting the number of bits used to represent the refined index, memory consumption can be matched to a given level of complexity in the encoding process. Unlike the internal state of model probabilities using CABAC—where there are 64 probability state indices—the use of table lookups to map model probabilities to specific PIPE codes is avoided, and no further transformation is required.

[0181] Next, we will describe a scalable complexity context model update according to one embodiment.

[0182] To update the context model, its stochastic state index may be updated based on one or more previously encoded bins. In an HE-PIPE setup, this update is performed after encoding or decoding each bin. Conversely, in an LC-PIPE setup, this update may never be performed.

[0183] However, it is possible to perform context model updates in a way that is scalable in terms of complexity. That is, the decision of whether or not to update a context model may be based on a variety of factors. For example, a certain coder setup may not be able to perform updates for certain context models, such as the context model for the syntax element coeff_significant_flag, while always performing updates for all other context models.

[0184] In other words, the selection unit 402 is configured to perform selection among the entropy decoders 322 for each symbol of a certain set of symbol types, and in this case, depending on the respective probability model associated with each set of symbol types, the selection may be made such that the number of set of symbol types is smaller in the low-complexity mode than in the high-efficiency mode.

[0185] Furthermore, the criteria for controlling whether or not to update the context model may be, for example, the size of the bitstream packet or the number of bins that have been decoded up to that point, or the update may be performed only after a specific fixed or variable number of bins relating to the context model have been encoded.

[0186] Using this scheme to decide whether or not to update the context model, context model updates that are scalable in complexity can be implemented. These updates can increase or decrease the number of bins in the bitstream in which the context model update is performed. The more context model updates there are, the better the encoding efficiency and the greater the computational complexity. Thus, using the above scheme, context model updates that are scalable in complexity can be achieved.

[0187] In a preferred embodiment, the context model update is performed for all syntax element bins 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 with respect to 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. After a certain predetermined number of transformation blocks have been processed, the context model updates are invalidated for all context models until the end of the slice is reached.

[0190] For example, the selection unit 402 may perform the selection between entropy decoders 322 with respect to symbols of a predetermined symbol type, depending on a probabilistic model associated with that predetermined symbol type, either together with or without updating the associated probabilistic model. In this case, the length of the learning phase of the symbol sequence in which the selection for symbols of the predetermined symbol type is performed together with the update may 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 the complexity of the internal state of the context model is represented in a scalable way, in which 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. The table storing the "second part" becomes unnecessary and can therefore be deleted, given that context model updates are invalidated for all context models (as described in the previously described preferred embodiment).

[0192] Next, we will describe the context model update for a bin array according to one embodiment.

[0193] In the LC-PIPE configuration, the bins of syntax elements of types coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 are grouped into multiple subsets. For each subset, a single context model is used to encode its bins. In this case, a context model update may be performed after encoding a fixed number of bins in this column. This is referred to below as a multi-bin update. However, this update may differ from an 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 encoded bin.

[0194] The following is an example of encoding an exemplary subset consisting of eight bins. The letter "b" represents the decoding of one bin, and the letter "u" represents the updating of the context model. In the case of LC-PIPE, only bin decoding is performed without updating the context model. bbbbbbbb

[0195] In the case of HE-PIPE, the context model update is performed after each bin has been decoded. bububububububu

[0196] To reduce complexity somewhat, context model updates may be performed after the bin sequence (in this example, these four bins are updated after each of the four bins have been decoded). bbbbuuuubbbbuuuu

[0197] In other words, the selection unit 402 may be configured to perform selection among the entropy decoders 322 with respect to symbols of a predetermined symbol type, depending on a probability model associated with that predetermined symbol type, with or without updating the associated probability model. In this case, the number of times selection for symbols of a predetermined symbol type is performed with the update may be lower in the low-complexity mode than in the high-efficiency mode.

[0198] In this case, after the decryption of the four bins, four update steps follow based on those four newly decrypted bins. Note that these four update steps can also be performed in a single step using a special lookup table reference. This lookup table stores the new state resulting after the four conventional update steps for each possible combination of the four bins and each possible internal state of the context model.

[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 encoded 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, 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 all of these bins have been encoded. The number n can 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 just coeff_significant_flag). Therefore, 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 single-bin updates are used for one of these subsets and context model updates are not used for the other. Any possible disjoint subsets (including an empty subset) are valid.

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

[0201] In other words, the selection unit 402 may perform the selection among the entropy decoders 322 with respect to symbols of a predetermined symbol type, depending on a probability model associated with that predetermined symbol type, and along with that selection, it may update the associated probability model for every nth symbol of a predetermined type based on m recent symbols of that predetermined symbol type, and the ratio n / m may be higher in the low-complexity mode than in the high-efficiency mode.

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

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

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

[0205] Two different modes are valid 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 equivalent to the case where 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 refined index. The two parts of the 8-bit initialization value are expressed as follows:

[0206] TIFF2026083042000008.tif31150

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

[0208] TIFF2026083042000009.tif49150

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

[0210] TIFF2026083042000010.tif56150

[0211] QP and the 8-bit initialization value are necessary for calculating the initialization of the internal state of the probabilistic model by operating 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 (the first part of the 8-bit initialization value), and b represents the PIPE coder (the 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. In other cases, valMps is 0 and pipeIdx is equal to (2047 - y) >> 8. When valMps is equal to 1, the refinement index is equal to (((y - 2048) & 255) * numStates) >> 8. In other cases, the refinement index is equal to (((2047-y)&255)*numStates)>>8. In both cases, numStates is equal to the number of CABAC states in pipeIdx shown in Table B.

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

[0213] If the slope of the 8-bit initialization value is not equal to zero, or if QP is not equal to 26, the internal state must be computed using a linear equation with the QP of the encoding or decoding process. If the slope is equal to zero, or if 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 probabilistic model. In other cases, the resulting decimal part of the internal state may be further used to determine the refinement index in the high-efficiency encoding application by linear interpolation between the limits of a particular PIPE coder. In this preferred embodiment, the linear interpolation is performed by simply multiplying the decimal part by the total number of refinement indices valid for the current PIPE coder and mapping the result to the nearest integer refinement index.

[0214] The process of initializing the internal state of the probabilistic model can vary in relation to the number of PIPE probabilistic index states. In particular, the use of two different PIPE indices to distinguish between MPS being 1 or 0, i.e., the dual occurrence of equally likely modes using PIPE coder E1, can be avoided as follows. Here again, this process can be initiated during the initial period of analysis of slice data, and furthermore, the input to this process may be 8-bit initialization values ​​as shown in Table E, which may be transmitted, for example, within a bitstream for each context model to be initialized.

[0215] TIFF2026083042000011.tif32150

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

[0217] TIFF2026083042000012.tif29150

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

[0219] TIFF2026083042000013.tif40150

[0220] The calculation of the internal state is performed using both values ​​with a linear equation such as y = m*x + 256*b, where m is the slope, x is 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 (y) of this process represents the internal state of the probabilistic 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] TIFF2026083042000014.tif29150

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

[0223] TIFF2026083042000015.tif82150

[0224] In one preferred embodiment, probIdx is defined in QP26. Based on an 8-bit initialization value, the internal state of a probabilistic model (valMps, pipeIdx, and refineIdx) is processed as described by the following pseudocode. TIFF2026083042000016.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 identifies the total number of refineIdx for each pipeIdx. The interval [7,8) of fullCtxState / 256 is split in half. The interval [7,7.5) is mapped to pipeIdx=0 and valMps=0, and the interval [7.5,8) is mapped 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 exhibits a dependency on probIdx and QP. When the 8-bit initialization value slopeIdx is equal to 7, the resulting internal state of the probabilistic model is identical for all slice QPs, and therefore the initialization process of the internal state is independent of the slice's current QP.

[0227] In other words, the selector 402 may initialize a pipe index to be used when decoding the subsequent portion of the data stream, such as the entire stream or the next slice, using a syntax element indicating the quantization step size QP, where the quantization step size QP is used to quantize the data of this subsequent portion, including data such as transformation coefficient levels contained therein, into a single table common to both LC and HE modes, using this syntax element as an index. A table like Table D may contain pipe indexes 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 calculate the pipe index value by multiplying a by (QP-QPref), for example, using the actual QP and each table entry a indicated by QP itself. The only difference between LC mode and HE mode is that the selector calculates the result with lower precision in LC mode than in HE mode. The selector may use, for example, only the integer part of the calculation result. In HE mode, a higher-precision residue, such as a fractional part, is used to select one of the valid refined indices for each pipe index, indicated by a lower-precision or integer part. The refined index is used in HE mode (and potentially less frequently in LC mode), and probabilistic adaptation is performed, for example, by using the table walk described above. If a valid index for the current pipe index is to be maintained at its high-frequency boundary, that high pipe index is then selected by minimizing its refined index. If a valid index for the current pipe index is to be maintained at its low-frequency boundary, the next lower pipe index is then selected by maximizing its refined index to the maximum valid value for the new pipe index. While pipe indices and refined indices define a probabilistic state, for selection between partial streams, the selection unit uses only pipe indices.The refined index only serves to track the probability model closer or with more precise accuracy.

[0228] However, the above description shows that scalability in complexity can be achieved even when using the decoder shown in FIG. 12, independently of the PIPE or CABAC coding concepts of FIGS. 7 to 17. The decoder of FIG. 12 decodes a data stream 601 in which media data is encoded therein, and includes a mode switch 600 configured to activate a low-complexity mode or a high-efficiency mode depending on the data stream 601, and a de-symbolizer 602 configured to obtain an integer-valued syntax element 604 by de-symbolizing a symbol sequence 603 obtained from the data stream 601 - either directly or via, for example, entropy decoding - using a mapping function controllable by control parameters. The mapping function is for mapping the domain of the symbol sequence word to the co-domain of the integer-valued syntax element. The reconstruction unit 605 is configured to reconstruct media data 606 based on the integer-valued syntax element. The de-symbolizer 602 is configured to perform its de-symbolization as follows. That is, the control parameter changes at a first rate depending on the data stream as indicated by arrow 607 when the high-efficiency mode is activated, while when the low-complexity mode is activated, the control parameter is either constant regardless of the data stream or changes at a second rate lower than the first rate depending on the data stream. For example, the control parameter may change depending on the previously de-symbolized symbols.

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

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

[0231] Figure 13 shows an encoder compatible with the decoder of Figure 11 for encoding media data into a data stream. This encoder may include an insertion unit 500 configured to signal the activation of either a low-complexity mode or a high-efficiency mode within the 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 plurality of entropy encoders 310, each configured to convert a partial sequence of symbols into a codeword in the data stream; and a selection unit 502 configured to send each symbol of the sequence of symbols 508 to one of the selected entropy encoders 310, where the selection unit 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. An interleaver 510 may optionally be provided to interleave the codewords of the encoders 310.

[0232] Figure 14 shows an encoder compatible with the decoder in Figure 12 for encoding media data into a data stream. This encoder includes an insertion unit 700 configured to signal the activation of either a low-complexity mode or a high-efficiency mode within the data stream 701; a construction unit 704 configured to precode media data 705 into a syntax element sequence 706 containing integer syntax elements; and a symbolizer 707 for mapping the domains of integer syntax elements to the co-domains of symbol sequence words, the symbolizer 707 configured to symbolize integer syntax elements using a mapping function controllable by a control parameter, wherein the symbolizer 707 is configured to perform its symbolization as follows: the control parameter changes at a first rate depending on the data stream when the high-efficiency mode is activated, as indicated by arrow 708; on the other hand, when the low-complexity mode is activated, the control parameter is configured to be constant regardless of the data stream or to change depending on the data stream but at a second rate lower than the first rate. The symbolization result is encoded into data stream 701.

[0233] It should be noted that the embodiment in Figure 14 is easily convertible to the context-adaptive binary arithmetic coding / decoding embodiment described above. In that case, the selection unit 509 and the entropy encoder 310 would be condensed into a single context-adaptive binary arithmetic encoder that directly outputs the data stream 401 and selects the context for the bins to be derived from the data stream at this point. This is true in particular for context adaptability and / or probabilistic adaptability. In low complexity mode, both functionality and adaptability may be switched off or designed to be more relaxed.

[0234] It has been briefly mentioned that the mode switching capability described in some of the embodiments above may not be necessary in other embodiments. To clarify this point, please refer to Figure 16. This figure is used in the explanation because the embodiment in Figure 16 differs from the embodiments described above only in that the mode switching capability has been removed. Furthermore, the following explanation will reveal the advantages obtained as a result of initializing the context probability estimation using parameters with lower precision than, for example, H.264, with respect to the slope and offset.

[0235] Specifically, Figure 16 shows a decoder for decoding video from a data stream 401 in which syntax element 327 is encoded, using the binaryization of syntax element 327. It should be noted that all the details described above with respect to Figures 1 to 15 can also be translated into the items shown in Figure 16, for example, with respect to the functions of the de-symbolizer 314, the reconstruction unit 404, and the entropy decoder 409. However, for the sake of completeness, some of these details will be described again below.

[0236] The decoder includes an entropy decoder 409 configured to derive several bins 36 of a binaryization from the data stream 401 using binary entropy decoding by selecting one context from among different contexts and updating the probabilistic states associated with those different contexts, depending on the previously decoded portion of the data stream 401. More specifically, as described above, the entropy decoder 409 may be configured to derive several bins 326 of a binaryization from the data stream 401 using binary entropy decoding such as the CABAC scheme described above or binary PIPE decoding, i.e., using a structure including multiple entropy decoders 322 operating in parallel and their respective selection / assignment units. As far as context selection is concerned, its dependence on previously decoded portions of the data stream 401 may be embodied as described above. In other words, the entropy decoder may be configured to perform context selection for the bin to be derived, depending on the position of the bin to be derived within the binarization to which the bin to be derived belongs, the type of syntax element whose integer value is obtained by de-binarizing the binarization to which the bin to be derived belongs, or the integer values ​​of one or more bins previously derived from the data stream 401 or previously de-binarized syntax elements. For example, the selected context may differ 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 transformation coefficient levels, motion vector differences, coding mode parameters, and so on.

[0237] As far as updating stochastic states is concerned, the entropy decoder 409 may be configured to perform an update on the currently derived bin by transitioning from the current stochastic state associated with the context selected for the currently derived bin among the 126 stochastic states to a new stochastic state among the 126, depending on the currently derived bin. As described above, the entropy decoder 409 may access a table entry using, for example, the current state and the value of the currently derived bin, and the accessed table entry may indicate a new stochastic state. See the tables Next_State_LPS and Next_State_MPS described above. In addition to the other steps 0-5 described above, a table lookup on those tables is performed by the entropy decoder. In the above description, stochastic states were sometimes represented as pState_current[bin]. Furthermore, as described above, the entropy decoder 409 may be configured to binary arithmetically decode the bin to be derived by performing interval subdivision, thereby subdividing the current probability interval into two partial intervals, by quantizing the current probability interval bit value (R) representing the current probability interval to obtain a probability interval index q_index, and further indexing one table entry in the table entry (Rtab) using the probability interval index and a probability state index p_state which depends on the current probability state related to the context selected for the bin to be derived, and thereby subdividing the current probability interval into two partial intervals. As described above, the entropy decoder 409 may use an 8-bit representation for the value of the current probability interval width R. To quantize the value of the current probability interval width, the entropy decoder 409 may, for example, take two or three of the most significant bits of the 8-bit representation.

[0238] The entropy decoder 409 then performs a selection between two subintervals based on the offset state value from within the current probability interval, updates the probability interval width value and the offset state value, further estimates the bin value to be derived using the selected subinterval, and may perform renormalization of the updated probability interval width and the offset state value, i.e., V in the above description, which may include continuing to read bits from the data stream 401. As described above, the selection between two subintervals based on the offset state value V may include a comparison between R and V, while the updating of the probability interval width value and the offset state value may depend on the bin value to be derived.

[0239] Continuing the explanation of Figure 16, the decoder further includes a desymbolizer 314 configured to de-binarize the binaryization of syntax element 327 to obtain an integer value of the syntax element. The reconstruction unit 404, further included in the decoder of Figure 16, then reconstructs the video 405 using the quantization parameter QP based on the integer value of the syntax element. For example, the reconstruction unit 404 may operate in a predictive manner as described above, and together with the quantization parameter, it may set an accuracy for representing the predictive residue, such as a transformation coefficient level that represents a transformed version of the predictive residue. The entropy decoder 409 is configured to distinguish 126 probabilistic states as described above. That is, pState_current[bin], combined with the indication of valMPS, i.e., between 0 and 1, i.e., between possible symbolic states, can represent 126 different states. The entropy decoder 409 initializes the stochastic states associated with various contexts, i.e., pState_current for various valid contexts, according to the linear equation of the quantization parameters, i.e., the equation a·QP+d. Here, it should be remembered that pState_current actually indicates only the probability of the LSB. Thus, a·QP+d represents both, i.e., pState_current and valMPS, which indicate which of the two states is the MBS and which is the LBS. While a·QP+d indicates the probability of a given symbol, i.e., 1 or 0, the fact that a·QP+d is greater than 63 directly indicates whether 0 or 1 is the MSB. For each of the various contexts, the entropy decoder 126 derives the slope a and offset b of the linear equation from the first and second 4-bit portions of the respective 8-bit initialization value, i.e., the four MSBs and the four lower LSBs. In this regard, the entropy decoder 409 may be configured to initialize probabilities relevant to various contexts as starting points for slices of video. The entropy decoder may also be configured to individually determine, for example, the quantization parameters for each slice of video.In other words, the entropy decoder 409 may derive information from the data stream 401 about 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 each slice. "At the beginning of a slice" may mean, for example, "before decoding the first bin that is to be entropy-decoded using some 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 each probability state associated with a different context at the beginning of each slice of video, and to initialize each probability state associated with a different context according to a linear equation of the quantization parameters for the current slice, where the entropy decoder may derive the slope and offset of the linear equation for each slice from the first and second 4-bit portions of the same 8-bit initialization value. In other words, the quantization parameter QP changes between slices of video, while the slope-offset pair does not change.

[0240] As described above, the reconstruction unit 404 may operate in a predictive manner. Accordingly, when reconstructing the video 405 based on the integer values ​​of the syntax element 327, the reconstruction unit 404 may dequantize the transformation coefficient levels contained in the syntax element using the quantization parameter QP, perform a retransformation on the dequantized transformation coefficient levels to obtain a prediction residue, perform spatial and / or temporal predictions to obtain a prediction signal, and further combine the prediction residue and the prediction signal to reconstruct the video 405.

[0241] To give a specific example, the entropy decoder 409 may be configured to independently derive the slope and offset for each of the different contexts from the first and second 4-bit portions, for example by the table lookup described above, or alternatively by using separate arithmetic operations such as linear operations. That is, to bridge the gap between the case where one set of 4 bits from the two 4-bit portions of the 8-bit initialization value is one, and the other set of 126 different probability state values ​​is the other, the entropy decoder 409 may individually fit both 4-bit portions into each linear equation. For example, the MSB p of the 8-bit initialization value is converted to the slope by performing the operation slope = m·p + n, and the four LSBs q of the 8-bit initialization value are used to calculate the offset by offset = s·q + t, where m, n, t, and s are appropriately selected constants. For the sake of completeness only, Figure 17 shows an encoder that fits the decoder of Figure 16. Here, the encoder in Figure 17 closely corresponds to the encoder in Figure 20, for example, and the encoders of other embodiments, similar to how the decoder in Figure 16 corresponds to the decoder in Figure 11. That is, the correspondence is except for the exclusion of mode switching capability and the implementation of the entropy encoder 513 under more comprehensive conditions, including the concept of PIPE or other concepts such as the CABAC concept described above. In addition, all descriptions made in relation to Figure 16 can be equally applied to Figure 17.

[0242] While several embodiments have been shown in the context of describing the apparatus, it is clear that these embodiments also describe the corresponding methods, and that the blocks or apparatus correspond to method steps or features of method steps. Similarly, embodiments shown in the context of describing method steps also represent corresponding blocks, items, or features of the corresponding apparatus. Some or all of the method steps may be performed by (or using) hardware devices such as 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 devices.

[0243] The encoded signals of the present invention may be stored in a digital storage medium, or they may be transmitted by a transmission medium such as a wireless transmission medium like the internet or a wired transmission medium.

[0244] Depending on the specified configuration requirements, embodiments of the present invention can be implemented in hardware or software. This implementation can be carried out using a digital storage medium, such as a flexible disk, DVD, Blu-ray, CD, ROM, PROM, EPROM, EEPROM, flash memory, etc., which has electronically readable control signals stored therein and cooperates (or can cooperate) with a computer system that can be programmed to perform each method of the present invention. Accordingly, the digital storage medium may be computer-readable.

[0245] Some embodiments of the present invention may include a data carrier having an electronically readable control signal, which can cooperate with a computer system programmable to perform one of the methods described above.

[0246] Generally, embodiments of the present invention can be implemented as a computer program product having program code, which can be operated to execute one of the methods of the present invention when the computer program product is running on a computer. The program code may be stored, for example, on a machine-readable carrier.

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

[0248] In other words, one embodiment of the method of the present invention is a computer program having program code for performing one of the above-described methods when the computer program is running on a computer.

[0249] Another embodiment of the present invention is a data carrier (or digital storage medium or computer-readable medium) containing a computer program recorded to execute 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 present invention is a data stream or signal sequence representing a computer program for executing one of the methods described above. The data stream or signal sequence may be configured to be transmitted via, for example, a data communication connection over the Internet.

[0251] Another embodiment includes processing means, such as a computer or programmable logic device, configured or adapted to execute one of the methods described above.

[0252] Another embodiment includes a computer in which a computer program for executing one of the methods described above is installed.

[0253] A further embodiment according to the present invention includes an apparatus or system configured to transfer (e.g., electronically or optically) a computer program for executing one of the methods described herein to a receiver. The receiver may be, for example, a computer, a portable device, a memory device, etc. The apparatus or system may include, for example, a file server for transferring the computer program to the receiver.

[0254] In some embodiments, a programmable logic device (such as a rewritable gate array) may be used to execute some or all of the functions of the methods described above. In some embodiments, the rewritable gate array may cooperate with a microprocessor to execute one of the methods described above. Generally, such methods are preferably executed by any hardware device.

[0255] The embodiments described above are merely illustrative examples illustrating the principles of the present invention. It will be apparent to those skilled in the art that the configurations and details described herein can be modified and altered. Accordingly, the present invention should not be limited by the specific details presented herein for the purpose of describing and explaining the embodiments, but only by the appended claims.

[0256] [Claim 1] A decoder for decoding video from a data stream (401) where the syntax element (327) has been encoded using the binaryization of this syntax element, An entropy decoder (409) derives several bins (326) of the binaryization from the data stream (401) using binary entropy decoding by selecting one context from among different contexts based on a previously decoded portion of the data stream (401) and updating the probabilistic state associated with the different context, A desymbolizer (314) obtains an integer value of the syntax element (327) by inversely binarizing the binaryization of the syntax element (327), The system comprises a reconstruction unit (404) that reconstructs the video using quantization parameters based on the integer values ​​of the syntax elements, The decoder is configured such that the entropy decoder (409) distinguishes 126 stochastic states and initializes the stochastic states associated with the different contexts according to a linear equation of the quantization parameters, and for each of the different contexts, the entropy decoder derives the slope and 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] In the decoder according to claim 1, The decoder is configured to derive several bins (326) of the binaryization from the data stream (401) using binary arithmetic decoding or binary PIPE decoding, wherein the entropy decoder (409) is configured to derive several bins (326) of the binaryization from the data stream (401). [Claim 3] In the decoder according to claim 1 or 2, The bin position of the bin to be derived within the binization to which the bin to be derived belongs, The syntax element type of the syntax element whose integer value is obtained by inverse binarizing the binaryization to which the bin to be derived currently belongs, Depending on one or more of the integer values ​​of one or more bins previously derived from the data stream (401), or previously de-binarized syntax elements, A decoder wherein the entropy decoder (409) is configured to perform context selection for the bin to be derived. [Claim 4] In the decoder according to any one of claims 1 to 3, The entropy decoder (409) is configured to update the probabilistic state for the currently derived bin by, depending on the currently derived bin, transitioning from the current probabilistic state associated with the context selected for the currently derived bin among the 126 probabilistic states to a new probabilistic state among the 126 probabilistic states. [Claim 5] In the decoder according to any one of claims 1 to 4, The decoder (409) is configured to binary arithmetic decode the bin to be derived by performing interval subdivision, subdividing the current probability interval into two partial intervals, by obtaining a probability interval index by quantizing a current probability interval width value representing the current probability interval, and further indexing one table entry in the table entry using the probability interval index and a probability state index that depends on the current probability state associated with the context selected for the bin to be derived, thereby subdividing the current probability interval into two partial intervals. [Claim 6] In the 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 take two or three of the most significant bits of the 8-bit representation when quantizing the current probability interval width value. [Claim 7] In the decoder according to claim 5 or 6, The decoder 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, estimate the bin value to be derived now using the selected sub-interval, and perform renormalization of the updated probability interval width value and the offset state value, including continuous reading of bits from the data stream (401). [Claim 8] A decoder according to any one of claims 1 to 7, wherein the entropy decoder (409) is configured to initialize the probabilistic state associated with the different contexts at the start of the slice of the video. [Claim 9] A decoder according to claim 8, wherein the entropy decoder (409) is configured to individually determine the quantization parameters for each slice of the video. [Claim 10] In the decoder according to any one of claims 1 to 9, The entropy decoder (409) is configured to initialize the probabilistic state associated with the different context at the start of a slice of the video by reading the quantization parameters for the current slice from the data stream (401) and initializing the probabilistic state associated with the different context according to a linear equation of the quantization parameters for the current slice, The entropy decoder (409) is configured to derive the slope and offset of the linear equation from a first 4-bit portion and a second 4-bit portion of the same 8-bit initialization value for each slice. [Claim 11] In the decoder according to any one of claims 1 to 10, The decoder is configured such that, in reconstructing the video (405) based on the integer values ​​of the syntax elements (327), it inversely quantizes the conversion coefficient levels included in the syntax elements using the quantization parameters, performs a re-transformation on the inversely quantized conversion coefficient levels to obtain a prediction residue, performs spatial and / or temporal prediction to obtain a prediction signal, and further combines the prediction residue and the prediction signal to reconstruct the video (405). [Claim 12] In the decoder according to any one of claims 1 to 11, The entropy decoder (409) is configured to derive the slope and offset of the linear equation independently of each of the different contexts from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 13] In the decoder according to any one of claims 1 to 12, The entropy decoder is configured to derive the slope and offset of the linear equation for each of the different contexts using a table lookup or arithmetic operations from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 14] In the decoder according to any one of claims 1 to 12, The entropy decoder is configured to derive the slope of the linear equation for each of the different contexts by multiplying the first 4-bit portion by a first pair of parameters and offsetting it, and to derive the offset of the linear equation by multiplying the second 4-bit portion by a second pair of parameters and offsetting it. [Claim 15] An encoder that encodes video into a data stream by encoding the syntax elements into a data stream using the binaryization of the syntax elements, A construction unit that represents the video by setting integer values ​​of the syntax elements depending on the quantization parameters, A symbolizer that obtains the binaryization of the syntax element by binarizing the integer value of the syntax element, The system comprises an entropy encoder that encodes several bins of the binaryization into the data stream using binary entropy coding by selecting one context from among different contexts depending on a previously encoded portion of the data stream and updating the probabilistic state associated with the different context, An encoder wherein the entropy encoder is configured to distinguish 126 stochastic states and initialize the stochastic states associated with the different contexts according to a linear equation of the quantization parameters, and the entropy encoder is configured to derive the slope and offset of the linear equation from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value for each of the different contexts. [Claim 16] In the encoder according to claim 15, The entropy encoder is configured to encode some bins of the binaryization into the data stream using binary arithmetic coding or binary PIPE coding. [Claim 17] In the encoder according to claim 15 or 16, The bin position of the bin to be encoded within the binaryization to which the bin to be encoded belongs, The syntax element type of the syntax element whose integer value is binarized into the binaryization to which the bin to be encoded currently belongs, The data stream depends on one or more of the following: one or more bins previously encoded, or the integer values ​​of syntax elements previously encoded, An encoder configured to perform context selection for the bin to be encoded, wherein the entropy encoder is configured to perform context selection for the bin to be encoded. [Claim 18] In the encoder according to any one of claims 15 to 17, The entropy encoder is configured to update the probabilistic state for the currently encoded bin by, depending on the currently encoded bin, transitioning from the current probabilistic state associated with the context selected for the currently encoded bin among the 126 probabilistic states to a new probabilistic state among the 126 probabilistic states. [Claim 19] In the encoder according to any one of claims 15 to 18, The encoder is configured to binary arithmetic encode the bin to be encoded by performing interval subdivision, thereby subdividing the current probability interval into two partial intervals, by obtaining a probability interval index by quantizing a current probability interval width value representing the current probability interval, and further performing interval subdivision by indexing a table entry in the table entry using the probability interval index and a probability state index that depends on the current probability state associated with the context selected for the bin to be encoded, thereby subdividing the current probability interval into two partial intervals. [Claim 20] In the encoder according to claim 19, The entropy encoder is configured to use an 8-bit representation for the current probability interval width value and to take two or three of the most significant bits of the 8-bit representation when quantizing the current probability interval width value. [Claim 21] In the encoder according to claim 19 or 20, The entropy encoder is configured to select within the two sub-intervals based on the integer value of the bin to be encoded, update the probability interval width value and the probability interval offset using the selected sub-interval, and perform renormalization of the probability interval width value and the probability interval offset, which includes continuous writing of bits to the data stream. [Claim 22] In the encoder according to any one of claims 15 to 21, The entropy decoder is an encoder configured to initialize the probabilistic state associated with a different context at the beginning of each slice of the video. [Claim 23] In the encoder according to any one of claims 15 to 22, The entropy encoder is configured to initialize the probabilistic state associated with a different context at the beginning of each slice of the video. [Claim 24] In the encoder according to any one of claims 15 to 23, The entropy encoder is configured to initialize the probabilistic states associated with different contexts at the start of each slice of the video by individually setting the quantization parameters for the current slice from the data stream and initializing the probabilistic states associated with different contexts according to a linear equation of the quantization parameters for the current slice, The entropy encoder is configured to derive the slope and offset of the linear equation from a first 4-bit portion and a second 4-bit portion of the same 8-bit initialization value for each slice. [Claim 25] In the encoder according to any one of claims 15 to 24, The constructor is configured to set integer values ​​for the syntax elements by performing spatial and / or temporal predictions to obtain a predicted signal, deriving a prediction residue from the predicted signal and the video, performing a transformation on the prediction residue to obtain a transformation coefficient level, and obtaining a quantized transformation coefficient level included in the syntax element by quantizing the transformation coefficient level using the quantization parameter. [Claim 26] In the encoder according to any one of claims 15 to 25, The entropy encoder is configured to derive the slope and offset of the linear equation independently of each of the different contexts from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 27] In the encoder according to any one of claims 15 to 26, The entropy encoder is configured to derive the slope and offset of the linear equation for each of the different contexts using a table lookup or arithmetic operations from a first 4-bit portion and a second 4-bit portion of each 8-bit initialization value. [Claim 28] In the encoder according to any one of claims 15 to 27, The entropy encoder is configured to derive the slope of the linear equation for each of the different contexts by multiplying the first 4-bit portion by a first pair of parameters and offsetting it, and to derive the offset of the linear equation by multiplying the second 4-bit portion by a second pair of parameters and offsetting it. [Claim 29] A method for decoding video from a data stream, wherein the syntax elements are encoded using the binaryization of these syntax elements, The steps include: deriving several bins of the binaryization from the data stream using binary entropy decoding by selecting one context from among different contexts based on a previously decoded portion of the data stream and updating the probabilistic state associated with the different context; The steps include obtaining an integer value of the syntax element by inversely binarizing the binaryization of the syntax element, The process includes the step of reconstructing the video using quantization parameters based on integer values ​​of the syntax elements, The step of deriving several bins of the binaryization distinguishes 126 stochastic states, the method further includes initializing the stochastic states associated with the different contexts according to a linear equation of the quantization parameters, and for each of the different contexts, deriving the slope and 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] A method for encoding video into a data stream by encoding the syntax elements into a data stream using binaryization of the syntax elements, The steps include representing the video by setting integer values ​​of the syntax elements depending on the quantization parameters, The steps include: binarizing the integer values ​​of the syntax elements to obtain the binary representation of the syntax elements; The process includes the step of encoding several binaries of the binaryization into the data stream using binary entropy coding, by selecting one context from among different contexts depending on a previously encoded portion of the data stream and updating the probabilistic state associated with the different context, The step of representing the video is to distinguish 126 stochastic states, and the method further includes initializing the stochastic states associated with the different contexts according to a linear equation of the quantization parameters, and for each of the different contexts, deriving the slope and 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 program code for performing the method described in claim 29 or 30 when run on a computer.

Claims

1. A non-temporary recording medium readable by a computer equipped with a processor for recording video-related data streams, The data structure of the data stream includes encoded syntax elements related to the video, wherein the syntax elements are entropy encoded based on one or more contexts used in binary entropy coding, wherein the data structure of the data stream includes instructions for the processor, which, when decoding the data of a slice of video, obtains from the data stream at least the quantization parameters associated with the slice and the slope value of the equation to be initialized to initialize at least one of the contexts, wherein the processor obtains from the data stream a 4-bit portion of the 8-bit initialization value associated with at least one context to derive the slope value based on the 4-bit portion. A non-temporary recording medium that can be read by a computer.

2. The data stream includes at least a portion relating to color samples of the video. A computer-readable, non-temporary recording medium as described in claim 1.

3. The data stream includes at least a portion relating to depth values ​​associated with the video depth map, A computer-readable, non-temporary recording medium as described in claim 1.

Images